package com.smart.translator.ota;

import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattService;
import android.content.Context;
import android.util.Log;
import com.smart.translator.ble.BleManager;
import com.smart.translator.ble.AudioProcessor;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.UUID;
import java.io.BufferedInputStream;
import android.bluetooth.BluetoothGattDescriptor;
import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

/**
 * OTA管理器 - 完全按照OTASampleCode1.2.5的协议实现
 */
public class OtaManager {
    private static final String TAG = "OtaManager";
    
    // OTA相关的UUID (来自OTASampleCode1.2.5的真实UUID定义)
    // CM3 OTA服务UUID
    private static final UUID OTA_SERVICE_UUID = UUID.fromString("02f00000-0000-0000-0000-00000000fe00");
    private static final UUID OTA_SEND_CHARACTERISTIC_UUID = UUID.fromString("02f00000-0000-0000-0000-00000000ff01");
    private static final UUID OTA_RECV_CHARACTERISTIC_UUID = UUID.fromString("02f00000-0000-0000-0000-00000000ff02");
    
    // DSP OTA服务UUID（与设备一致）
    private static final UUID OTA_SERVICE_UUID_DSP = UUID.fromString("02f00000-0000-0000-0000-00000000fd00");
    private static final UUID OTA_CHAR_UUID_VERSION_INFO_DSP = UUID.fromString("02f00000-0000-0000-0000-00000000fe00");
    private static final UUID OTA_CHAR_UUID_TX_DSP = UUID.fromString("02f00000-0000-0000-0000-00000000fe01");
    private static final UUID OTA_CHAR_UUID_RX_DSP = UUID.fromString("02f00000-0000-0000-0000-00000000fe02");
    private static final UUID OTA_CHAR_UUID_NOTI_DSP = UUID.fromString("02f00000-0000-0000-0000-00000000fe03");
    
    // 外部Flash OTA服务UUID（与设备一致）
    private static final UUID OTA_SERVICE_UUID_EXTERNAL_FLASH = UUID.fromString("02f00000-0000-0000-0000-00000000fc00");
    private static final UUID OTA_CHAR_UUID_VERSION_INFO_EXTERNAL_FLASH = UUID.fromString("02f00000-0000-0000-0000-00000000fd03");
    private static final UUID OTA_CHAR_UUID_TX_EXTERNAL_FLASH = UUID.fromString("02f00000-0000-0000-0000-00000000fd00");
    private static final UUID OTA_CHAR_UUID_RX_EXTERNAL_FLASH = UUID.fromString("02f00000-0000-0000-0000-00000000fd01");
    private static final UUID OTA_CHAR_UUID_NOTI_EXTERNAL_FLASH = UUID.fromString("02f00000-0000-0000-0000-00000000fd02");
    
    private static final UUID OTA_DESCRIPTOR_UUID = UUID.fromString("00002902-0000-1000-8000-00805f9b34fb");
    
    // OTA类型枚举
    public enum OtaType {
        CM3("CM3程序"),
        DSP("DSP程序"),
        EXTERNAL_FLASH("外部Flash程序");  // 新增外部Flash OTA类型
        
        private final String displayName;
        
        OtaType(String displayName) {
            this.displayName = displayName;
        }
        
        public String getDisplayName() {
            return displayName;
        }
    }
    
    // OTA命令定义 (来自设备端代码的实际枚举值)
    // CM3 OTA命令 (来自ota.h中的ota_cmd_t枚举)
    private static final int OTA_CMD_NVDS_TYPE = 0;
    private static final int OTA_CMD_GET_STR_BASE = 1;
    private static final int OTA_CMD_READ_FW_VER = 2;    // 读取固件版本
    private static final int OTA_CMD_PAGE_ERASE = 3;
    private static final int OTA_CMD_CHIP_ERASE = 4;
    private static final int OTA_CMD_WRITE_DATA = 5;
    private static final int OTA_CMD_READ_DATA = 6;
    private static final int OTA_CMD_WRITE_MEM = 7;
    private static final int OTA_CMD_READ_MEM = 8;
    private static final int OTA_CMD_REBOOT = 9;
    private static final int OTA_CMD_NULL = 10;
    
    // DSP OTA命令 (来自ota_dsp.h中的ota_dsp_cmd_t枚举，与CM3 OTA使用相同的值)
    private static final int OTA_CMD_DSP_NVDS_TYPE = 0;      // 修正：使用设备端实际值
    private static final int OTA_CMD_DSP_GET_STR_BASE = 1;   // 修正：使用设备端实际值
    private static final int OTA_CMD_DSP_READ_FW_VER = 2;    // 修正：使用设备端实际值
    private static final int OTA_CMD_DSP_PAGE_ERASE = 3;     // 修正：使用设备端实际值
    private static final int OTA_CMD_DSP_CHIP_ERASE = 4;     // 修正：使用设备端实际值
    private static final int OTA_CMD_DSP_WRITE_DATA = 5;     // 修正：使用设备端实际值
    private static final int OTA_CMD_DSP_READ_DATA = 6;      // 修正：使用设备端实际值
    private static final int OTA_CMD_DSP_WRITE_MEM = 7;      // 修正：使用设备端实际值
    private static final int OTA_CMD_DSP_READ_MEM = 8;       // 修正：使用设备端实际值
    private static final int OTA_CMD_DSP_REBOOT = 9;         // 修正：使用设备端实际值
    private static final int OTA_CMD_DSP_NULL = 10;          // 修正：使用设备端实际值
    
    // DSP OTA特殊命令 (这些是DSP特有的，不在标准枚举中)
    private static final int OTA_CMD_DSP_GET_DATA_BASE = 22;  // 保持原有值
    private static final int OTA_CMD_DSP_GET_CLK0_BASE = 23;  // 保持原有值
    private static final int OTA_CMD_DSP_GET_CLK1_BASE = 24;  // 保持原有值
    private static final int OTA_CMD_DSP_GET_CLK2_BASE = 25;  // 保持原有值
    private static final int OTA_CMD_DSP_GET_CLK3_BASE = 26;  // 保持原有值
    private static final int OTA_CMD_DSP_GET_CLK4_BASE = 27;  // 保持原有值
    
    // 外部Flash OTA命令 (来自ota_flash.h中的ota_flash_cmd_t枚举)
//    private static final int OTA_FLASH_CMD_NVDS_TYPE = 0;
//    private static final int OTA_FLASH_CMD_GET_STR_BASE = 1;
//    private static final int OTA_FLASH_CMD_READ_FW_VER = 2;
//    private static final int OTA_FLASH_CMD_PAGE_ERASE = 3;
//    private static final int OTA_FLASH_CMD_CHIP_ERASE = 4;
//    private static final int OTA_FLASH_CMD_WRITE_DATA = 5;
//    private static final int OTA_FLASH_CMD_READ_DATA = 6;
//    private static final int OTA_FLASH_CMD_REBOOT = 9;
//    private static final int OTA_FLASH_CMD_FLASH_IDENTIFY = 10;  // 识别外部flash
//    private static final int OTA_FLASH_CMD_FLASH_ERASE = 11;     // 擦除外部flash扇区
//    private static final int OTA_FLASH_CMD_FLASH_WRITE = 12;     // 写入外部flash
//    private static final int OTA_FLASH_CMD_FLASH_READ = 13;      // 读取外部flash
//    private static final int OTA_FLASH_CMD_NULL = 14;
//
    // 外部Flash OTA命令 (简化的协议)
    private static final int OTA_FLASH_CMD_GET_VERSION = 0x01;    // 获取版本信息
    private static final int OTA_FLASH_CMD_ERASE_FLASH = 0x02;    // 擦除Flash (参数0-2表示擦除0-2个4KB扇区)
    private static final int OTA_FLASH_CMD_WRITE_DATA = 0x03;     // 写入数据
    private static final int OTA_FLASH_CMD_READ_DATA = 0x04;      // 读取数据


    private static final int OTA_FLASH_CMD_REBOOT = 0x05;
    // 简化的响应定义
    private static final int OTA_FLASH_RSP_SUCCESS = 0x00;        // 成功
    private static final int OTA_FLASH_RSP_ERROR = 0x01;          // 错误
    
    // OTA状态
    public static final int OTA_STATE_IDLE = 0;
    public static final int OTA_STATE_CONNECTING = 1;
    public static final int OTA_STATE_CONNECTED = 2;
    public static final int OTA_STATE_UPDATING = 3;
    public static final int OTA_STATE_COMPLETED = 4;
    public static final int OTA_STATE_ERROR = 5;
    
    // 单例实例
    private static volatile OtaManager instance;
    
    // 上下文和BLE管理器
    private Context context;
    private BleManager bleManager;
    
    // OTA状态
    private int currentState = OTA_STATE_IDLE;
    private int updateProgress = 0;
    private String currentStatus = "准备就绪";
    
    // 固件文件
    private File firmwareFile;
    private byte[] firmwareData;
    
    // 回调接口
    private OtaCallback otaCallback;
    
    // OTA传输相关 - 优化MTU大小和包大小
    private int mtuSize = 247; // 默认MTU大小
    private int maxPacketSize = 512; // 优化包大小，减少头部开销
    private int totalPackets = 0;
    private int currentPacket = 0;
    private boolean isUpdating = false;
    
    // 添加写入锁，防止并发写入冲突
    private final Object writeLock = new Object();
    
    // 添加OTA类型锁，防止并发修改currentOtaType
    private final Object otaTypeLock = new Object();
    
    // 自适应延迟控制 - 不依赖连接参数更新
    private int writeSuccessCount = 0;
    private int writeFailureCount = 0;
    private int currentDelay = 30; // 增加初始延迟到30ms
    private static final int MIN_DELAY = 30; // 最小延迟30ms
    private static final int MAX_DELAY = 100; // 最大延迟100ms（失败时使用）
    
    // 性能统计
    private long lastWriteTime = 0;
    private int totalWrites = 0;
    private int successfulWrites = 0;
    private double averageWriteInterval = 0;
    
    // 连接参数
    private double connectionIntervalMs = 7.5; // 默认连接间隔7.5ms
    private int connectionLatency = 0; // 连接延迟
    private int connectionTimeoutMs = 500; // 连接超时
    private boolean connectionParametersUpdated = false; // 连接参数是否已更新
    
    // OTA状态管理 - 按照OTASampleCode1.2.5的简单标志位机制
    private int recv_data = 0; // 0=未收到响应, 1=收到响应
    private byte[] recvValue = null;
    private boolean writeStatus = false; // 写入状态标志
    private int connectState = 0;
    
    // 版本信息
    private int majorVersion = 0;
    private int minorVersion = 0;
    private int patchVersion = 0;
    
    // CM3版本信息
    private int cm3MajorVersion = 0;
    private int cm3MinorVersion = 0;
    private int cm3PatchVersion = 0;
    
    // DSP版本信息
    private int dspMajorVersion = 0;
    private int dspMinorVersion = 0;
    private int dspPatchVersion = 0;
    
    // 外部Flash版本信息
    private int externalFlashMajorVersion = 0;
    private int externalFlashMinorVersion = 0;
    private int externalFlashPatchVersion = 0;
    
    // 当前OTA类型
    private OtaType currentOtaType = OtaType.CM3;
    
    // 版本请求进度标志
    private boolean isVersionRequestInProgress = false;
    
    // ⭐ 修复：添加防重复调用机制
    private long lastCanStartCheckTime = 0;
    private boolean lastCanStartResult = false;
    
    // OTA特征 - 支持CM3和DSP两种类型
    private BluetoothGattCharacteristic otaSendCharacteristic;
    private BluetoothGattCharacteristic otaRecvCharacteristic;
    
    // DSP OTA特征
    private BluetoothGattCharacteristic dspOtaSendCharacteristic;
    private BluetoothGattCharacteristic dspOtaRecvCharacteristic;
    private BluetoothGattCharacteristic dspOtaNotiCharacteristic;
    private BluetoothGattCharacteristic dspOtaVersionInfoCharacteristic;
    
    // 外部Flash OTA特征
    private BluetoothGattCharacteristic externalFlashOtaRxCharacteristic;  // 用于写入命令
    private BluetoothGattCharacteristic externalFlashOtaTxCharacteristic;  // 用于读取数据
    private BluetoothGattCharacteristic externalFlashOtaNotiCharacteristic;
    private BluetoothGattCharacteristic externalFlashOtaVersionInfoCharacteristic;
    
    // CRC表 (来自OTASampleCode1.2.5)
    private final int[] crc_table = {
        0, 1996959894, -301047508, -1727442502, 124634137, 1886057615, -379345611, -1637575261, 249268274, 2044508324, -522852066, -1747789432, 162941995, 2125561021, -407360249, -1866523247, 498536548, 1789927666, -205950648, -2067906082, 450548861, 1843258603, -187386543, -2083289657, 325883990, 1684777152, -43845254, -1973040660, 335633487, 1661365465, -99664541, -1928851979, 997073096, 1281953886, -715111964, -1570279054, 1006888145, 1258607687, -770865667, -1526024853, 901097722, 1119000684, -608450090, -1396901568, 853044451, 1172266101, -589951537, -1412350631, 651767980, 1373503546, -925412992, -1076862698, 565507253, 1454621731, -809855591, -1195530993, 671266974, 1594198024, -972236366, -1324619484, 795835527, 1483230225, -1050600021, -1234817731, 1994146192, 31158534, -1731059524, -271249366, 1907459465, 112637215, -1614814043, -390540237, 2013776290, 251722036, -1777751922, -519137256, 2137656763, 141376813, -1855689577, -429695999, 1802195444, 476864866, -2056965928, -228458418, 1812370925, 453092731, -2113342271, -183516073, 1706088902, 314042704, -1950435094, -54949764, 1658658271, 366619977, -1932296973, -69972891, 1303535960, 984961486, -1547960204, -725929758, 1256170817, 1037604311, -1529756563, -740887301, 1131014506, 879679996, -1385723834, -631195440, 1141124467, 855842277, -1442165665, -586318647, 1342533948, 654459306, -1106571248, -921952122, 1466479909, 544179635, -1184443383, -832445281, 1591671054, 702138776, -1328506846, -942167884, 1504918807, 783551873, -1212326853, -1061524307, -306674912, -1698712650, 62317068, 1957810842, -355121351, -1647151185, 81470997, 1943803523, -480048366, -1805370492, 225274430, 2053790376, -468791541, -1828061283, 167816743, 2097651377, -267414716, -2029476910, 503444072, 1762050814, -144550051, -2140837941, 426522225, 1852507879, -19653770, -1982649376, 282753626, 1742555852, -105259153, -1900089351, 397917763, 1622183637, -690576408, -1580100738, 953729732, 1340076626, -776247311, -1497606297, 1068828381, 1219638859, -670225446, -1358292148, 906185462, 1090812512, -547295293, -1469587627, 829329135, 1181335161, -882789492, -1134132454, 628085408, 1382605366, -871598187, -1156888829, 570562233, 1426400815, -977650754, -1296233688, 733239954, 1555261956, -1026031705, -1244606671, 752459403, 1541320221, -1687895376, -328994266, 1969922972, 40735498, -1677130071, -351390145, 1913087877, 83908371, -1782625662, -491226604, 2075208622, 213261112, -1831694693, -438977011, 2094854071, 198958881, -2032938284, -237706686, 1759359992, 534414190, -2118248755, -155638181, 1873836001, 414664567, -2012718362, -15766928, 1711684554, 285281116, -1889165569, -127750551, 1634467795, 376229701, -1609899400, -686959890, 1308918612, 956543938, -1486412191, -799009033, 1231636301, 1047427035, -1362007478, -640263460, 1088359270, 936918000, -1447252397, -558129467, 1202900863, 817233897, -1111625188, -893730166, 1404277552, 615818150, -1160759803, -841546093, 1423857449, 601450431, -1285129682, -1000256840, 1567103746, 711928724, -1274298825, -1022587231, 1510334235, 755167117
    };
    
    public interface OtaCallback {
        void onProgress(int progress, String message);
        void onSuccess(String message);
        void onError(String error);
        void onVersionReceived(String version); // 新增版本信息回调
        void onVersionReceived(OtaType otaType, String version); // 新增带OTA类型的版本信息回调
        void onVersionCheckComplete(); // 新增：版本检查完成回调
    }
    
    private OtaManager() {}
    
    public static OtaManager getInstance() {
        if (instance == null) {
            synchronized (OtaManager.class) {
                if (instance == null) {
                    instance = new OtaManager();
                }
            }
        }
        return instance;
    }
    
    /**
     * 初始化OTA管理器
     */
    public void init(Context context, BleManager bleManager) {
        this.context = context;
        this.bleManager = bleManager;
        
        // 获取OTA特征
        BluetoothGatt gatt = bleManager.getBluetoothGatt();
        if (gatt != null) {
            // 初始化CM3 OTA服务
            initCm3OtaService(gatt);
            
            // 初始化DSP OTA服务
            initDspOtaService(gatt);
            
            // 初始化外部Flash OTA服务
            initExternalFlashOtaService(gatt);
            
        } else {
            Log.e(TAG, "BluetoothGatt为空");
        }
        
        setState(OTA_STATE_IDLE);
    }
    
    /**
     * 初始化CM3 OTA服务
     */
    private void initCm3OtaService(BluetoothGatt gatt) {
        BluetoothGattService otaService = gatt.getService(OTA_SERVICE_UUID);
        if (otaService != null) {
            Log.d(TAG, "找到CM3 OTA服务");
            
            // 获取发送特征
            otaSendCharacteristic = otaService.getCharacteristic(OTA_SEND_CHARACTERISTIC_UUID);
            if (otaSendCharacteristic != null) {
                Log.d(TAG, "找到CM3 OTA发送特征: " + otaSendCharacteristic.getUuid());
            }
            
            // 获取接收特征并设置通知
            otaRecvCharacteristic = otaService.getCharacteristic(OTA_RECV_CHARACTERISTIC_UUID);
            if (otaRecvCharacteristic != null) {
                Log.d(TAG, "找到CM3 OTA接收特征: " + otaRecvCharacteristic.getUuid());
                // 交给BleManager队列
                BleManager.getInstance().addNotifyCharacteristic(otaRecvCharacteristic);
            }
        } else {
            Log.w(TAG, "未找到CM3 OTA服务: " + OTA_SERVICE_UUID);
        }
    }
    
    /**
     * 初始化DSP OTA服务
     */
    private void initDspOtaService(BluetoothGatt gatt) {
        BluetoothGattService dspOtaService = gatt.getService(OTA_SERVICE_UUID_DSP);
        if (dspOtaService != null) {
            Log.d(TAG, "DSP OTA服务发现成功");
            
            // 获取DSP OTA特征
            dspOtaVersionInfoCharacteristic = dspOtaService.getCharacteristic(OTA_CHAR_UUID_VERSION_INFO_DSP);
            dspOtaSendCharacteristic = dspOtaService.getCharacteristic(OTA_CHAR_UUID_TX_DSP);
            dspOtaRecvCharacteristic = dspOtaService.getCharacteristic(OTA_CHAR_UUID_RX_DSP);
            dspOtaNotiCharacteristic = dspOtaService.getCharacteristic(OTA_CHAR_UUID_NOTI_DSP);
            
            if (dspOtaVersionInfoCharacteristic != null && dspOtaSendCharacteristic != null && 
                dspOtaRecvCharacteristic != null && dspOtaNotiCharacteristic != null) {
                Log.d(TAG, "DSP OTA特征发现成功");
                
                // 启用DSP OTA通知
                BluetoothGattDescriptor descriptor = dspOtaNotiCharacteristic.getDescriptor(OTA_DESCRIPTOR_UUID);
                if (descriptor != null) {
                    gatt.setCharacteristicNotification(dspOtaNotiCharacteristic, true);
                    descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
                    gatt.writeDescriptor(descriptor);
                    Log.d(TAG, "DSP OTA通知启用成功");
                }
                // 交给BleManager队列
                BleManager.getInstance().addNotifyCharacteristic(dspOtaNotiCharacteristic);
            } else {
                Log.w(TAG, "DSP OTA特征发现失败");
            }
        } else {
            Log.w(TAG, "DSP OTA服务未发现");
        }
    }
    
    private void initExternalFlashOtaService(BluetoothGatt gatt) {
        BluetoothGattService externalFlashOtaService = gatt.getService(OTA_SERVICE_UUID_EXTERNAL_FLASH);
        if (externalFlashOtaService != null) {
            Log.d(TAG, "外部Flash OTA服务发现成功");
            
            // 添加Flash OTA详细日志
            Log.d("External Flash OTA", "外部Flash OTA服务初始化开始");
            Log.d("External Flash OTA", "服务UUID: " + OTA_SERVICE_UUID_EXTERNAL_FLASH);
            
            // 获取外部Flash OTA特征
            externalFlashOtaVersionInfoCharacteristic = externalFlashOtaService.getCharacteristic(OTA_CHAR_UUID_VERSION_INFO_EXTERNAL_FLASH);
            externalFlashOtaRxCharacteristic = externalFlashOtaService.getCharacteristic(OTA_CHAR_UUID_RX_EXTERNAL_FLASH);  // RX用于写入命令
            externalFlashOtaTxCharacteristic = externalFlashOtaService.getCharacteristic(OTA_CHAR_UUID_TX_EXTERNAL_FLASH);  // TX用于读取数据
            externalFlashOtaNotiCharacteristic = externalFlashOtaService.getCharacteristic(OTA_CHAR_UUID_NOTI_EXTERNAL_FLASH);
            
            if (externalFlashOtaVersionInfoCharacteristic != null && externalFlashOtaRxCharacteristic != null && 
                externalFlashOtaTxCharacteristic != null && externalFlashOtaNotiCharacteristic != null) {
                Log.d(TAG, "外部Flash OTA特征发现成功");
                
                // 添加Flash OTA特征详情日志
                Log.d("External Flash OTA", "外部Flash OTA特征发现成功");
                Log.d("External Flash OTA", "版本信息特征UUID: " + OTA_CHAR_UUID_VERSION_INFO_EXTERNAL_FLASH);
                Log.d("External Flash OTA", "RX特征UUID(写入): " + OTA_CHAR_UUID_RX_EXTERNAL_FLASH);
                Log.d("External Flash OTA", "TX特征UUID(读取): " + OTA_CHAR_UUID_TX_EXTERNAL_FLASH);
                Log.d("External Flash OTA", "通知特征UUID: " + OTA_CHAR_UUID_NOTI_EXTERNAL_FLASH);
                
                // 启用外部Flash OTA通知
                BluetoothGattDescriptor descriptor = externalFlashOtaNotiCharacteristic.getDescriptor(OTA_DESCRIPTOR_UUID);
                if (descriptor != null) {
                    gatt.setCharacteristicNotification(externalFlashOtaNotiCharacteristic, true);
                    descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
                    gatt.writeDescriptor(descriptor);
                    Log.d(TAG, "外部Flash OTA通知启用成功");
                    Log.d("External Flash OTA", "外部Flash OTA通知启用成功");
                }
                // 交给BleManager队列
                BleManager.getInstance().addNotifyCharacteristic(externalFlashOtaNotiCharacteristic);
            } else {
                Log.w(TAG, "外部Flash OTA特征发现失败");
                Log.w("External Flash OTA", "外部Flash OTA特征发现失败");
                
                // 添加Flash OTA特征失败详情日志
                Log.w("External Flash OTA", "版本信息特征: " + (externalFlashOtaVersionInfoCharacteristic != null ? "已找到" : "未找到"));
                Log.w("External Flash OTA", "RX特征: " + (externalFlashOtaRxCharacteristic != null ? "已找到" : "未找到"));
                Log.w("External Flash OTA", "TX特征: " + (externalFlashOtaTxCharacteristic != null ? "已找到" : "未找到"));
                Log.w("External Flash OTA", "通知特征: " + (externalFlashOtaNotiCharacteristic != null ? "已找到" : "未找到"));
            }
        } else {
            Log.w(TAG, "外部Flash OTA服务未发现");
            Log.w("External Flash OTA", "外部Flash OTA服务未发现");
            Log.w("External Flash OTA", "期望的服务UUID: " + OTA_SERVICE_UUID_EXTERNAL_FLASH);
        }
    }
    
    public void setCallback(OtaCallback callback) {
        this.otaCallback = callback;
    }
    
    public int getCurrentState() {
        return currentState;
    }
    
    public int getUpdateProgress() {
        return updateProgress;
    }
    
    public String getCurrentStatus() {
        return currentStatus;
    }
    
    /**
     * 设置状态
     */
    private void setState(int state) {
        this.currentState = state;
        switch (state) {
            case OTA_STATE_IDLE:
                currentStatus = "准备就绪";
                break;
            case OTA_STATE_CONNECTING:
                currentStatus = "连接中...";
                break;
            case OTA_STATE_CONNECTED:
                currentStatus = "已连接";
                break;
            case OTA_STATE_UPDATING:
                currentStatus = "更新中...";
                break;
            case OTA_STATE_COMPLETED:
                currentStatus = "更新完成";
                break;
            case OTA_STATE_ERROR:
                currentStatus = "更新失败";
                break;
        }
        
        if (otaCallback != null) {
            otaCallback.onProgress(updateProgress, currentStatus);
        }
    }
    
    /**
     * 更新进度
     */
    private void updateProgress(int progress, String message) {
        this.updateProgress = progress;
        this.currentStatus = message;
        
        if (otaCallback != null) {
            otaCallback.onProgress(progress, message);
        }
    }
    
    /**
     * 检查是否可以开始新的OTA更新
     */
    public boolean canStartNewOta() {
        // ⭐ 修复：添加防重复调用机制
        long currentTime = System.currentTimeMillis();
        if (currentTime - lastCanStartCheckTime < 1000) { // 1秒内不重复检查
            Log.d(TAG, "canStartNewOta检查过于频繁，跳过");
            return lastCanStartResult;
        }
        lastCanStartCheckTime = currentTime;
        
        Log.d(TAG, "=== 检查是否可以开始新的OTA更新 ===");
        
        // 检查当前状态
        if (currentState == OTA_STATE_UPDATING) {
            Log.w(TAG, "OTA更新正在进行中，无法开始新的更新");
            lastCanStartResult = false;
            return false;
        }
        
        if (isUpdating) {
            Log.w(TAG, "OTA更新标志位为true，无法开始新的更新");
            lastCanStartResult = false;
            return false;
        }
        
        // ⭐ 修复：减少重复的BLE连接检查，只在必要时检查
        boolean bleConnected = isBleConnected();
        if (!bleConnected) {
            Log.w(TAG, "BLE未连接，无法开始OTA更新");
            lastCanStartResult = false;
            return false;
        }
        
        // ⭐ 修复：检查所有OTA类型的特征可用性，而不是只检查currentOtaType
        boolean anyOtaAvailable = isCm3OtaAvailable() || isDspOtaAvailable() || isExternalFlashOtaAvailable();
        if (!anyOtaAvailable) {
            Log.w(TAG, "所有OTA特征都不可用，无法开始更新");
            Log.d(TAG, "CM3可用: " + isCm3OtaAvailable() + ", DSP可用: " + isDspOtaAvailable() + ", 外部Flash可用: " + isExternalFlashOtaAvailable());
            lastCanStartResult = false;
            return false;
        }
        
        Log.d(TAG, "✅ 可以开始新的OTA更新");
        Log.d(TAG, "=== 检查完成 ===");
        lastCanStartResult = true;
        return true;
    }
    
    /**
     * 启动OTA更新 (完全按照OTASampleCode1.2.5的协议)
     */
    public void startUpdate(String firmwarePath, OtaType otaType, OtaCallback callback) {
        // ⭐ 修复：添加防重复调用机制
        if (isUpdating || currentState == OTA_STATE_UPDATING) {
            Log.w(TAG, "OTA更新正在进行中，忽略重复调用");
            if (callback != null) {
                callback.onError("OTA更新正在进行中，请等待完成");
            }
            return;
        }
        
        Log.d(TAG, "=== 开始OTA更新流程 ===");
        Log.d(TAG, "OTA类型: " + otaType.getDisplayName());
        Log.d(TAG, "固件路径: " + firmwarePath);
        
        if (!canStartNewOta()) {
            Log.e(TAG, "无法开始OTA更新，状态检查失败");
            if (callback != null) {
                callback.onError("无法开始OTA更新，请检查设备连接状态");
            }
            return;
        }
        
        // 在开始新的OTA更新前，完全重置状态
        Log.d(TAG, "开始新的OTA更新，重置所有状态");
        resetAllState();
        
        this.otaCallback = callback;
        this.firmwareFile = new File(firmwarePath);
        
        // ⭐ 修复：使用同步锁保护currentOtaType的设置
        synchronized (otaTypeLock) {
            this.currentOtaType = otaType;
            Log.d(TAG, "设置当前OTA类型为: " + this.currentOtaType.getDisplayName());
        }
        
        if (!firmwareFile.exists()) {
            Log.e(TAG, "固件文件不存在: " + firmwarePath);
            if (callback != null) {
                callback.onError("固件文件不存在");
            }
            return;
        }
        
        // 验证固件文件
        if (!OtaUtils.isValidFirmwareFile(firmwarePath)) {
            Log.e(TAG, "固件文件格式无效");
            if (callback != null) {
                callback.onError("固件文件格式无效");
            }
            return;
        }
        
        // 读取固件数据
        try {
            firmwareData = OtaUtils.readFirmwareFile(firmwarePath);
            if (firmwareData == null || firmwareData.length == 0) {
                Log.e(TAG, "固件文件读取失败");
                if (callback != null) {
                    callback.onError("固件文件读取失败");
                }
                return;
            }
            Log.d(TAG, "固件文件读取成功，大小: " + firmwareData.length + " 字节");
        } catch (IOException e) {
            Log.e(TAG, "读取固件文件失败", e);
            if (callback != null) {
                callback.onError("读取固件文件失败: " + e.getMessage());
            }
            return;
        }
        
        // ⭐ 修复：减少重复的BLE连接检查，使用之前的结果
        if (bleManager == null || !bleManager.isConnected()) {
            Log.e(TAG, "BLE未连接");
            if (callback != null) {
                callback.onError("设备未连接");
            }
            return;
        }
        
        // ⭐ 修复：检查特定OTA类型的特征可用性
        boolean otaTypeAvailable = false;
        switch (otaType) {
            case CM3:
                otaTypeAvailable = isCm3OtaAvailable();
                break;
            case DSP:
                otaTypeAvailable = isDspOtaAvailable();
                break;
            case EXTERNAL_FLASH:
                otaTypeAvailable = isExternalFlashOtaAvailable();
                break;
        }
        
        if (!otaTypeAvailable) {
            Log.e(TAG, otaType.getDisplayName() + " OTA特征未找到");
            if (callback != null) {
                callback.onError(otaType.getDisplayName() + " OTA特征未找到");
            }
            return;
        }
        
        Log.d(TAG, "✅ 所有检查通过，开始OTA更新");
        setState(OTA_STATE_UPDATING);
        isUpdating = true;
        currentPacket = 0;
        // 使用优化的包大小计算总包数
        int actualPacketSize = Math.min(maxPacketSize, mtuSize - 9);
        totalPackets = (firmwareData.length + actualPacketSize - 1) / actualPacketSize;
        
        Log.d(TAG, "开始" + otaType.getDisplayName() + " OTA更新，固件大小: " + firmwareData.length + " 字节，总包数: " + totalPackets);
        Log.d(TAG, "MTU大小: " + mtuSize + ", 包大小: " + actualPacketSize);
        Log.d(TAG, "传输策略: WRITE_TYPE_DEFAULT + 固定20ms延迟");
        
        if (callback != null) {
            callback.onProgress(0, "开始" + otaType.getDisplayName() + " OTA更新...");
        }
        
        // 优化传输参数
        optimizeTransfer();
        
        // 启动OTA更新线程
        new Thread(() -> {
            try {
                performOtaUpdate();
            } catch (Exception e) {
                Log.e(TAG, otaType.getDisplayName() + " OTA更新失败", e);
                cleanupOtaState();
                setState(OTA_STATE_ERROR);
                if (callback != null) {
                    callback.onError(otaType.getDisplayName() + " OTA更新失败: " + e.getMessage());
                }
            }
        }).start();
        
        Log.d(TAG, "=== OTA更新流程启动完成 ===");
    }
    
    /**
     * 执行OTA更新 (完全按照OTASampleCode1.2.5的协议)
     */
    private void performOtaUpdate() throws InterruptedException, IOException {
        Log.d(TAG, "开始执行OTA更新，类型: " + currentOtaType.getDisplayName());
        
        // 确保在开始前重置状态，但保持isUpdating为true
        recv_data = 0;
        recvValue = null;
        writeStatus = false;
        currentPacket = 0;
        
        // 重新计算总包数，避免除零错误
        if (firmwareData != null) {
            // 修复：使用设备端实际接收的数据大小作为包大小
            // 设备端实际接收233字节，确保数据完整性
            // 虽然理论计算是MTU - 3 - 9 = 235字节，但实际传输中可能有额外开销
            int actualPacketSize = 233; // 设备端实际接收的数据大小
            totalPackets = (firmwareData.length + actualPacketSize - 1) / actualPacketSize;
            Log.d(TAG, "重新计算总包数: " + totalPackets + " (固件大小: " + firmwareData.length + ", 包大小: " + actualPacketSize + ")");
        } else {
            Log.e(TAG, "固件数据为空，无法计算总包数");
            throw new IOException("固件数据为空");
        }
        
        // 重置版本信息 - 在OTA更新时重新获取，避免使用过期信息
        majorVersion = 0;
        minorVersion = 0;
        patchVersion = 0;
        
        // 重置CM3和DSP版本信息
        cm3MajorVersion = 0;
        cm3MinorVersion = 0;
        cm3PatchVersion = 0;
        dspMajorVersion = 0;
        dspMinorVersion = 0;
        dspPatchVersion = 0;
        
        // 重置外部Flash版本信息
        externalFlashMajorVersion = 0;
        externalFlashMinorVersion = 0;
        externalFlashPatchVersion = 0;
        
        // 重置版本请求标志
        isVersionRequestInProgress = false;
        
        // 确保isUpdating保持为true
        isUpdating = true;
        
        // 1. 获取存储基地址
        Log.d(TAG, "获取存储基地址...");
        if (!send_data(getGetStrBaseCommand(), 0, null, 0)) {
            throw new IOException("发送获取基地址命令失败");
        }
        
        // 等待响应
        while (getRecv_data() != getGetStrBaseCommand()) {
            if (checkDisconnect()) {
                throw new IOException("设备连接断开");
            }
            Thread.sleep(1);
        }
        setRecv_data(0);
        
        // 从响应中解析基地址和版本信息 - 这是最新的、正确的地址
        int storageBaseAddress = parseStorageBaseAddress();
        Log.d(TAG, "OTA更新时获取的存储基地址: 0x" + Integer.toHexString(storageBaseAddress));
        Log.d(TAG, "设备当前版本: " + getDeviceVersion());
        
        // 通知版本信息
        if (otaCallback != null) {
            otaCallback.onProgress(5, "设备当前版本: " + getDeviceVersion());
        }
        
        // 适当延迟，确保设备准备就绪
        Thread.sleep(50); // 从10ms增加到50ms
        
        // ======【新增：整片擦除逻辑】======
        int eraseStart = storageBaseAddress;
        // 修复：使用正确的向上取整逻辑计算4K对齐的擦除长度
        int eraseLength = (int) Math.ceil((double) firmwareData.length / 0x1000) * 0x1000; // 固件大小向上4K对齐
        int eraseSectors = eraseLength / 0x1000; // 计算需要擦除的扇区数量
        
        Log.d(TAG, "开始整片擦除，起始地址: 0x" + Integer.toHexString(eraseStart) + 
              ", 固件大小: " + firmwareData.length + " 字节" +
              ", 擦除长度: 0x" + Integer.toHexString(eraseLength) + " 字节" +
              ", 擦除扇区数: " + eraseSectors);
        
        // 验证计算逻辑
        Log.d(TAG, "擦除长度计算验证:");
        Log.d(TAG, "  固件大小: " + firmwareData.length + " 字节");
        Log.d(TAG, "  向上4K对齐: Math.ceil(" + firmwareData.length + " / 4096) = " + Math.ceil((double) firmwareData.length / 0x1000));
        Log.d(TAG, "  擦除长度: " + Math.ceil((double) firmwareData.length / 0x1000) + " * 4096 = " + eraseLength + " 字节");
        Log.d(TAG, "  擦除扇区数: " + eraseLength + " / 4096 = " + eraseSectors);
        
        for (int i = 0; i < eraseSectors; i++) {
            int addr = eraseStart + (i * 0x1000);
            Log.d(TAG, "擦除扇区 " + (i + 1) + "/" + eraseSectors + ", 地址: 0x" + Integer.toHexString(addr));
            
            // 根据OTA类型选择正确的擦除命令
            int eraseCommand = getEraseCommand();
            
            // 根据OTA类型确定擦除大小参数
            int eraseSize = 0;
            if (currentOtaType == OtaType.EXTERNAL_FLASH) {
                // 外部Flash OTA需要传递擦除扇区数，而不是扇区大小
                // 每个扇区4KB，所以擦除扇区数 = 1
                eraseSize = 1; // 擦除1个4KB扇区
            }
            
            // 按照参考代码，重试发送直到成功
            while (!send_data(eraseCommand, addr, null, eraseSize)) {
                try {
                    Thread.sleep(50);
                    Log.d(TAG, "send_data error, retrying...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            
            // 等待写入状态标志（参考代码中的writeStatus）
            int delay_num = 0;
            while (!writeStatus) {
                delay_num += 1;
                if (delay_num % 8000 == 0) {
                    Log.d(TAG, "send_data once more");
                    send_data(eraseCommand, addr, null, eraseSize);
                }
                Thread.sleep(1);
            }
            
            // ⭐ 修复：等待擦除命令的响应，而不是getGetStrBaseCommand()
            int expectedEraseResponse = getEraseCommand();
            Log.d(TAG, "等待擦除响应，期望命令: " + expectedEraseResponse);
            
            // 使用超时机制等待擦除响应
            long eraseStartTime = System.currentTimeMillis();
            long eraseTimeout = 10000; // 10秒超时
            
            while (getRecv_data() != expectedEraseResponse) {
                if (checkDisconnect()) {
                    throw new IOException("设备连接断开");
                }
                
                // 检查超时
                if (System.currentTimeMillis() - eraseStartTime > eraseTimeout) {
                    Log.e(TAG, "等待擦除响应超时，当前recv_data: " + getRecv_data() + ", 期望: " + expectedEraseResponse);
                    throw new IOException("等待擦除响应超时，地址: 0x" + Integer.toHexString(addr));
                }
                
                Thread.sleep(1);
            }
            
            Log.d(TAG, "✅ 收到擦除响应: " + getRecv_data());
            setRecv_data(0);
            
            Log.d(TAG, "擦除完成，地址: 0x" + Integer.toHexString(addr));
        }
        Log.d(TAG, "整片擦除完成");
        // ======【擦除逻辑结束】======
        
        // 3. 发送固件数据
        int offset = 0;
        // 修复：考虑到BLE传输的实际限制，减少包大小确保数据传输完整性
        // 从日志分析，设备端实际接收231字节数据，但理论应该是238字节
        // 为了确保数据传输的完整性，将包大小设置为230字节
        int actualPacketSize = 230; // 减少包大小，确保数据传输完整性
        
        Log.d(TAG, "=== 开始固件数据传输 ===");
        Log.d(TAG, "固件总大小: " + firmwareData.length + " 字节");
        Log.d(TAG, "包大小: " + actualPacketSize + " 字节");
        Log.d(TAG, "总包数: " + totalPackets + " 包");
        Log.d(TAG, "存储基地址: 0x" + Integer.toHexString(storageBaseAddress));
        Log.d(TAG, "=== 固件传输参数设置完成 ===");
        
        while (offset < firmwareData.length && isUpdating) { // 添加isUpdating检查
            int remaining = firmwareData.length - offset;
            int packetSize = Math.min(actualPacketSize, remaining);
            
            byte[] packet = new byte[packetSize];
            System.arraycopy(firmwareData, offset, packet, 0, packetSize);
            
            // 计算写入地址：基地址 + 偏移量
            int writeAddress = storageBaseAddress + offset;
            
            // DSP OTA地址范围检查 - 根据设备端get_old_ota_dsp_address()逻辑
            if (currentOtaType == OtaType.DSP) {
                // 设备端返回的地址是get_old_ota_dsp_address()的结果
                // 这个地址可能是从Flash中读取的旧DSP地址，或者是默认计算的地址
                // 设备端已经确保了地址的有效性，我们只需要检查固件大小是否合理
                
                // 检查固件大小是否合理（DSP固件通常不会太大）
                if (firmwareData != null && firmwareData.length > 0x30000) { // 192KB
                    Log.w(TAG, "DSP固件大小(" + firmwareData.length + "字节)可能超出合理范围");
                }
                
                Log.d(TAG, "DSP OTA: 写入地址0x" + Integer.toHexString(writeAddress) + " (基地址: 0x" + Integer.toHexString(storageBaseAddress) + ")");
            }
            
            // 根据OTA类型选择正确的写入命令
            int writeCommand = getWriteCommand();
            
            // 发送数据包
            if (!send_data(writeCommand, writeAddress, packet, packetSize)) {
                throw new IOException("发送数据包失败，偏移: " + offset + ", 地址: 0x" + Integer.toHexString(writeAddress));
            }
            
            Log.d(TAG, "数据包发送成功，等待响应...");
            Log.d(TAG, "=== 数据包 " + (currentPacket + 1) + "/" + totalPackets + " 发送完成 ===");
            Log.d(TAG, "发送的数据包大小: " + packetSize + " 字节");
            Log.d(TAG, "期望的响应命令: " + writeCommand);
            Log.d(TAG, "=== 等待响应开始 ===");
            
            // ⭐ 修复：等待数据包响应，应该等待写入命令的响应，而不是getGetStrBaseCommand
            int expectedWriteResponse = writeCommand; // 等待写入命令的响应
            if (!waitForResponseWithTimeout(expectedWriteResponse, 5000)) { // 5秒超时
                Log.e(TAG, "等待数据包响应超时，偏移: " + offset + ", 地址: 0x" + Integer.toHexString(writeAddress));
                Log.e(TAG, "当前recv_data值: " + getRecv_data());
                Log.e(TAG, "期望的recv_data值: " + expectedWriteResponse);
                throw new IOException("等待数据包响应超时，偏移: " + offset);
            }
            
            Log.d(TAG, "=== 数据包 " + (currentPacket + 1) + "/" + totalPackets + " 响应接收成功 ===");
            Log.d(TAG, "实际收到的响应命令: " + getRecv_data());
            Log.d(TAG, "=== 数据包处理完成 ===");
            setRecv_data(0);
            
            offset += packetSize;
            currentPacket++;
            
            // 更新进度 - 添加除零保护
            int progress = 0;
            if (totalPackets > 0) {
                progress = (currentPacket * 100) / totalPackets;
            }
            updateProgress(progress, "发送数据包 " + currentPacket + "/" + totalPackets + " (地址: 0x" + Integer.toHexString(writeAddress) + ")");
            
            // 减少延迟，提高传输速度 - 移除包间延迟
            // Thread.sleep(2); // 移除这个延迟
        }
        
        // 检查是否被中断
        if (!isUpdating) {
            Log.w(TAG, "OTA更新被中断");
            return;
        }
        
        // 适当延迟，确保所有数据包都已处理完成
        Thread.sleep(100); // 从50ms增加到100ms
        
        // 4. 发送完成命令
        Log.d(TAG, "发送OTA完成命令");
        int rebootCommand = getRebootCommand();
        boolean rebootSuccess = send_data(rebootCommand, 0, null, 0);
        
        if (!rebootSuccess) {
            Log.w(TAG, "重启命令发送失败，但固件已成功写入，认为OTA成功");
            // 即使重启命令失败，固件已经成功写入，我们认为OTA是成功的
            // 设备可能会自动重启，或者用户需要手动重启
        } else {
            Log.d(TAG, "重启命令发送成功");
        }
        
        // 等待重启响应 - 设备会立即重启，不需要等待响应
        Thread.sleep(1000);
        
        // 5. 更新完成 - 延迟清理状态，等待设备重启
        Log.d(TAG, "OTA更新完成，设备即将重启");
        setState(OTA_STATE_COMPLETED);
        
        if (otaCallback != null) {
            otaCallback.onProgress(100, "OTA更新完成");
            otaCallback.onSuccess("固件更新成功，设备正在重启...");
        }
        
        // 延迟清理状态，等待设备重启并重新连接
        // 设备重启后会自动重新连接，此时需要重新初始化BLE特征
        new Thread(() -> {
            try {
                // ⭐ 优化：减少等待时间，因为现在主动重连
                Log.d(TAG, "等待设备重启...");
                Thread.sleep(2000); // 从12秒减少到8秒，确保设备完全重启
                
                // ⭐ 修复：主动尝试重新连接设备
                if (bleManager != null) {
                    Log.d(TAG, "尝试主动重新连接设备...");
                    // 使用BleManager的connectToLastDevice方法重新连接，使用强制重连模式
                    bleManager.connectToLastDevice(true); // 使用强制重连模式
                    
                    // 等待连接建立，最多尝试3次
                    for (int attempt = 1; attempt <= 3; attempt++) {
                        Log.d(TAG, "等待连接建立，尝试 " + attempt + "/3");
                        Thread.sleep(5000); // 等待5秒让连接建立
                        
                        if (bleManager.isConnected()) {
                            Log.d(TAG, "设备重新连接成功！");
                            break;
                        } else {
                            Log.w(TAG, "连接尝试 " + attempt + " 失败，继续尝试...");
                            if (attempt < 3) {
                                // 再次尝试连接，使用强制重连模式
                                bleManager.connectToLastDevice(true);
                            }
                        }
                    }
                }
                
                // ⭐ 修复：等待设备完全重启和初始化，确保OTA服务可用
                Log.d(TAG, "等待设备完全重启和OTA服务初始化...");
                Thread.sleep(8000); // 等待8秒，确保设备完全重启和OTA服务初始化
                
                // 检查设备是否已重新连接
                if (bleManager != null && bleManager.isConnected()) {
                    Log.d(TAG, "设备已重新连接，重新初始化OTA特征");
                    // 重新初始化BLE特征
                    if (bleManager.getBluetoothGatt() != null) {
                        // ⭐ 修复：等待服务发现完成后再初始化OTA特征
                        Log.d(TAG, "等待服务发现完成...");
                        Thread.sleep(3000); // 等待3秒让服务发现完成
                        
                        initCm3OtaService(bleManager.getBluetoothGatt());
                        initDspOtaService(bleManager.getBluetoothGatt());
                        initExternalFlashOtaService(bleManager.getBluetoothGatt());
                    }
                } else {
                    Log.w(TAG, "设备尚未重新连接，继续等待...");
                    // 再等待一段时间
                    Thread.sleep(8000);
                    
                    // 再次检查连接状态
                    if (bleManager != null && bleManager.isConnected()) {
                        Log.d(TAG, "设备已重新连接，重新初始化OTA特征");
                        if (bleManager.getBluetoothGatt() != null) {
                            // ⭐ 修复：等待服务发现完成后再初始化OTA特征
                            Log.d(TAG, "等待服务发现完成...");
                            Thread.sleep(3000); // 等待3秒让服务发现完成
                            
                            initCm3OtaService(bleManager.getBluetoothGatt());
                            initDspOtaService(bleManager.getBluetoothGatt());
                            initExternalFlashOtaService(bleManager.getBluetoothGatt());
                        }
                    } else {
                        Log.w(TAG, "设备重新连接超时，但继续清理状态");
                    }
                }
                
                // 最终清理OTA状态
                Log.d(TAG, "最终清理OTA状态");
                cleanupOtaState();
                
            } catch (InterruptedException e) {
                Log.w(TAG, "等待设备重启被中断");
                cleanupOtaState();
            }
        }).start();
    }
    
    /**
     * 根据当前OTA类型获取获取基地址命令
     */
    private int getGetStrBaseCommand() {
        switch (currentOtaType) {
            case CM3:
                return OTA_CMD_GET_STR_BASE;
            case DSP:
                return OTA_CMD_DSP_GET_STR_BASE;
            case EXTERNAL_FLASH:
                return OTA_FLASH_CMD_GET_VERSION;  // 使用简化的版本获取命令
            default:
                return OTA_CMD_GET_STR_BASE;
        }
    }
    
    /**
     * 根据当前OTA类型获取擦除命令
     */
    private int getEraseCommand() {
        switch (currentOtaType) {
            case CM3:
                return OTA_CMD_PAGE_ERASE;
            case DSP:
                return OTA_CMD_DSP_PAGE_ERASE;  // DSP OTA使用独立的命令值
            case EXTERNAL_FLASH:
                return OTA_FLASH_CMD_ERASE_FLASH; // 使用简化的Flash擦除命令
            default:
                return OTA_CMD_PAGE_ERASE;
        }
    }
    
    /**
     * 根据当前OTA类型获取写入命令
     */
    private int getWriteCommand() {
        switch (currentOtaType) {
            case CM3:
                return OTA_CMD_WRITE_DATA;
            case DSP:
                return OTA_CMD_DSP_WRITE_DATA;  // DSP OTA使用独立的命令值
            case EXTERNAL_FLASH:
                return OTA_FLASH_CMD_WRITE_DATA; // 使用简化的Flash写入命令
            default:
                return OTA_CMD_WRITE_DATA;
        }
    }
    
    /**
     * 根据当前OTA类型获取重启命令
     */
    private int getRebootCommand() {
        switch (currentOtaType) {
            case CM3:
                return OTA_CMD_REBOOT;
            case DSP:
                return OTA_CMD_REBOOT; // DSP使用与CM3相同的重启命令
            case EXTERNAL_FLASH:
                return OTA_FLASH_CMD_REBOOT; // 使用专门的Flash重启命令
            default:
                return OTA_CMD_REBOOT;
        }
    }
    
    /**
     * 自动获取设备版本信息（连接后调用）
     */
    public void requestDeviceVersion() {
        Log.d(TAG, "开始获取所有OTA类型的版本信息");
        
        // 防止重复调用
        if (isVersionRequestInProgress) {
            Log.w(TAG, "版本信息获取正在进行中，跳过重复调用");
            return;
        }
        
        // ⭐ 修复：检查是否正在进行OTA更新，如果是则跳过版本获取
        if (isUpdating || currentState == OTA_STATE_UPDATING) {
            Log.w(TAG, "OTA更新正在进行中，跳过版本获取");
            return;
        }
        
        isVersionRequestInProgress = true;
        
        // ⭐ 修复：将版本请求移到后台线程，避免主线程阻塞
        new Thread(() -> {
            try {
                // ⭐ 优化：减少初始等待时间，从2秒减少到500ms
                Log.d(TAG, "等待OTA特征初始化完成...");
                Thread.sleep(500); // 从2秒减少到500ms
                
                // ⭐ 修复：检查BLE连接和特征状态
                if (!isBleConnected()) {
                    Log.w(TAG, "BLE连接状态异常，跳过版本获取");
                    isVersionRequestInProgress = false;
                    return;
                }
                
                Log.d(TAG, "开始获取CM3版本信息");
                performSingleVersionRequest(OtaType.CM3);
                
                // ⭐ 优化：减少版本获取之间的延迟，从1秒减少到200ms
                Thread.sleep(200); // 从1秒减少到200ms
                Log.d(TAG, "开始获取DSP版本信息");
                performSingleVersionRequest(OtaType.DSP);
                
                // ⭐ 优化：减少版本获取之间的延迟，从1秒减少到200ms
                Thread.sleep(200); // 从1秒减少到200ms
                Log.d(TAG, "开始获取外部Flash版本信息");
                performSingleVersionRequest(OtaType.EXTERNAL_FLASH);
                
                Log.d(TAG, "所有OTA类型版本信息获取完成");
                
                checkOtaUpgrade();
            } catch (InterruptedException e) {
                Log.e(TAG, "版本获取被中断", e);
            } catch (Exception e) {
                Log.e(TAG, "版本获取发生异常", e);
            } finally {
                isVersionRequestInProgress = false;
            }
        }).start();
    }
    
    /**
     * 执行单个OTA类型的版本请求
     */
    private void performSingleVersionRequest(OtaType otaType) {
        Log.d(TAG, "执行版本请求，OTA类型: " + otaType.getDisplayName());
        
        // ⭐ 修复：增加详细的BLE连接状态检查日志
        Log.d(TAG, "=== " + otaType.getDisplayName() + " 版本请求状态检查 ===");
        Log.d(TAG, "- bleManager: " + (bleManager != null));
        if (bleManager != null) {
            Log.d(TAG, "- bleManager.isConnected(): " + bleManager.isConnected());
            Log.d(TAG, "- bleManager.getBluetoothGatt(): " + (bleManager.getBluetoothGatt() != null));
        }
        
        // 检查BLE连接状态
        if (!isBleConnected()) {
            Log.w(TAG, "BLE连接已断开，跳过" + otaType.getDisplayName() + "版本获取");
            Log.d(TAG, "isBleConnected() 详细检查:");
            Log.d(TAG, "  - bleManager != null: " + (bleManager != null));
            Log.d(TAG, "  - bleManager.isConnected(): " + (bleManager != null && bleManager.isConnected()));
            Log.d(TAG, "  - bleManager.getBluetoothGatt() != null: " + (bleManager != null && bleManager.getBluetoothGatt() != null));
            Log.d(TAG, "  - isCm3OtaAvailable(): " + isCm3OtaAvailable());
            Log.d(TAG, "  - isDspOtaAvailable(): " + isDspOtaAvailable());
            Log.d(TAG, "  - isExternalFlashOtaAvailable(): " + isExternalFlashOtaAvailable());
            return;
        }
        
        // ⭐ 修复：检查特定OTA类型的特征是否可用
        boolean otaAvailable = false;
        switch (otaType) {
            case CM3:
                otaAvailable = isCm3OtaAvailable();
                Log.d(TAG, "CM3 OTA特征检查:");
                Log.d(TAG, "  - otaSendCharacteristic: " + (otaSendCharacteristic != null ? "已设置" : "未设置"));
                Log.d(TAG, "  - otaRecvCharacteristic: " + (otaRecvCharacteristic != null ? "已设置" : "未设置"));
                break;
            case DSP:
                otaAvailable = isDspOtaAvailable();
                Log.d(TAG, "DSP OTA特征检查:");
                Log.d(TAG, "  - dspOtaSendCharacteristic: " + (dspOtaSendCharacteristic != null ? "已设置" : "未设置"));
                Log.d(TAG, "  - dspOtaRecvCharacteristic: " + (dspOtaRecvCharacteristic != null ? "已设置" : "未设置"));
                Log.d(TAG, "  - dspOtaNotiCharacteristic: " + (dspOtaNotiCharacteristic != null ? "已设置" : "未设置"));
                Log.d(TAG, "  - dspOtaVersionInfoCharacteristic: " + (dspOtaVersionInfoCharacteristic != null ? "已设置" : "未设置"));
                break;
            case EXTERNAL_FLASH:
                otaAvailable = isExternalFlashOtaAvailable();
                Log.d(TAG, "外部Flash OTA特征检查:");
                Log.d(TAG, "  - externalFlashOtaRxCharacteristic: " + (externalFlashOtaRxCharacteristic != null ? "已设置" : "未设置"));
                Log.d(TAG, "  - externalFlashOtaTxCharacteristic: " + (externalFlashOtaTxCharacteristic != null ? "已设置" : "未设置"));
                Log.d(TAG, "  - externalFlashOtaNotiCharacteristic: " + (externalFlashOtaNotiCharacteristic != null ? "已设置" : "未设置"));
                Log.d(TAG, "  - externalFlashOtaVersionInfoCharacteristic: " + (externalFlashOtaVersionInfoCharacteristic != null ? "已设置" : "未设置"));
                break;
        }
        
        if (!otaAvailable) {
            Log.w(TAG, otaType.getDisplayName() + " OTA特征不可用，跳过版本获取");
            Log.d(TAG, "CM3可用: " + isCm3OtaAvailable() + ", DSP可用: " + isDspOtaAvailable() + ", 外部Flash可用: " + isExternalFlashOtaAvailable());
            return;
        }
        
        Log.d(TAG, otaType.getDisplayName() + " OTA特征可用，继续版本获取");
        
        // ⭐ 修复：使用同步锁保护currentOtaType，确保在版本请求过程中不会被其他线程修改
        synchronized (otaTypeLock) {
            // 保存原始OTA类型，确保在方法结束时恢复
            OtaType originalOtaType = currentOtaType;
            
            try {
                // 设置当前OTA类型
                currentOtaType = otaType;
                Log.d(TAG, "设置当前OTA类型为: " + currentOtaType.getDisplayName());
                
                // 重置响应状态
                recv_data = 0;
                recvValue = null;
                writeStatus = false;
                
                // 根据OTA类型选择正确的获取基地址命令
                int getStrBaseCommand = getGetStrBaseCommand();
                Log.d(TAG, "获取到命令值: " + getStrBaseCommand + " (OTA类型: " + otaType.getDisplayName() + ")");
                
                // ⭐ 修复：发送命令前先等待一段时间，确保设备准备就绪
                Thread.sleep(50); // 从100ms减少到50ms
                
                // 发送获取基地址命令
                if (!send_data(getStrBaseCommand, 0, null, 0)) {
                    Log.e(TAG, "发送获取基地址命令失败，OTA类型: " + otaType.getDisplayName());
                    return;
                }
                
                // ⭐ 优化：减少版本获取超时时间到3秒，从5秒减少到3秒
                if (!waitForResponseWithTimeout(getStrBaseCommand, 3000)) { // 从5秒减少到3秒
                    Log.w(TAG, "等待版本响应超时，OTA类型: " + otaType.getDisplayName() + "，但继续其他操作");
                    return;
                }
                
                // 解析版本信息
                int baseAddress = parseStorageBaseAddress();
                String version = getDeviceVersion();
                
                Log.d(TAG, "获取到版本信息，OTA类型: " + otaType.getDisplayName() + 
                          ", 基地址: 0x" + Integer.toHexString(baseAddress) + 
                          ", 版本: " + version);
                
                // 通知回调
                if (otaCallback != null) {
                    otaCallback.onVersionReceived(otaType, version);
                }
                
            } catch (InterruptedException e) {
                Log.e(TAG, "版本请求被中断，OTA类型: " + otaType.getDisplayName(), e);
            } catch (Exception e) {
                Log.e(TAG, "版本请求发生异常，OTA类型: " + otaType.getDisplayName(), e);
            } finally {
                // ⭐ 修复：确保在方法结束时恢复原始OTA类型
                currentOtaType = originalOtaType;
                Log.d(TAG, "恢复原始OTA类型: " + currentOtaType.getDisplayName());
            }
        }
    }
    
    /**
     * 自动获取设备版本信息（连接后调用）
     */
    public void requestDeviceVersion(OtaType otaType) {
        Log.d(TAG, "开始检查" + otaType.getDisplayName() + " BLE连接状态...");
        Log.d(TAG, "- bleManager: " + (bleManager != null));
        if (bleManager != null) {
            Log.d(TAG, "- bleManager.isConnected(): " + bleManager.isConnected());
            Log.d(TAG, "- bleManager.getBluetoothGatt(): " + (bleManager.getBluetoothGatt() != null));
        }
        
        // ⭐ 修复：使用同步锁保护currentOtaType，确保在版本请求过程中不会被其他线程修改
        synchronized (otaTypeLock) {
            // 临时设置当前OTA类型进行检查
            OtaType originalType = currentOtaType;
            currentOtaType = otaType;
            
            Log.d(TAG, "- " + otaType.getDisplayName() + " OTA特征可用: " + isOtaCharacteristicsAvailable(otaType));
            
            if (!isBleConnected()) {
                Log.w(TAG, otaType.getDisplayName() + " BLE未连接，跳过版本获取");
                currentOtaType = originalType;
                return;
            }
            
            if (!isOtaCharacteristicsAvailable(otaType)) {
                Log.w(TAG, otaType.getDisplayName() + " OTA特征不可用，跳过版本获取");
                currentOtaType = originalType;
                return;
            }
            
            // ⭐ 修复：使用当前设置的otaType，而不是originalType
            performVersionRequest(otaType);
        }
    }
    
    /**
     * 执行版本请求
     */
    private void performVersionRequest(OtaType originalType) {
        Log.d(TAG, "开始获取" + originalType.getDisplayName() + "版本信息");
        
        // 检查BLE连接状态
        if (!isBleConnected()) {
            Log.w(TAG, "BLE连接已断开，无法获取版本信息");
            if (otaCallback != null) {
                otaCallback.onError("BLE连接已断开");
            }
            return;
        }
        
        // 检查OTA特征是否可用
        if (!isOtaCharacteristicsAvailable(originalType)) {
            Log.w(TAG, originalType.getDisplayName() + " OTA特征不可用");
            if (otaCallback != null) {
                otaCallback.onError(originalType.getDisplayName() + " OTA特征不可用");
            }
            return;
        }
        
        // ⭐ 修复：使用同步锁保护currentOtaType，确保在版本请求过程中不会被其他线程修改
        synchronized (otaTypeLock) {
            try {
                // 设置当前OTA类型
                currentOtaType = originalType;
                
                // 获取基地址和版本信息
                Log.d(TAG, "开始获取设备版本信息");
                
                // ⭐ 修复：增加版本获取超时时间到10秒，避免OTA更新中断
                int versionTimeoutMs = 3000; // 从10秒减少到3秒
                
                // 发送获取基地址命令
                int command = getGetStrBaseCommand();
                Log.d(TAG, "发送" + originalType.getDisplayName() + " OTA命令: " + bytesToHexString(cmd_operation(command, 0, 0)));
                
                // 等待响应
                if (waitForResponseWithTimeout(command, versionTimeoutMs)) {
                    // 解析基地址和版本信息
                    int baseAddress = parseStorageBaseAddress();
                    
                    // 根据OTA类型存储版本信息
                    switch (originalType) {
                        case CM3:
                            cm3MajorVersion = majorVersion;
                            cm3MinorVersion = minorVersion;
                            cm3PatchVersion = patchVersion;
                            Log.d(TAG, "存储CM3版本信息: " + majorVersion + "." + minorVersion + "." + patchVersion);
                            break;
                        case DSP:
                            dspMajorVersion = majorVersion;
                            dspMinorVersion = minorVersion;
                            dspPatchVersion = patchVersion;
                            Log.d(TAG, "存储DSP版本信息: " + majorVersion + "." + minorVersion + "." + patchVersion);
                            break;
                        case EXTERNAL_FLASH:
                            externalFlashMajorVersion = majorVersion;
                            externalFlashMinorVersion = minorVersion;
                            externalFlashPatchVersion = patchVersion;
                            Log.d(TAG, "存储外部Flash版本信息: " + majorVersion + "." + minorVersion + "." + patchVersion);
                            break;
                    }
                    
                    String versionString = majorVersion + "." + minorVersion + "." + patchVersion;
                    Log.i(TAG, "✅ " + originalType.getDisplayName() + "版本获取成功: " + versionString);
                    
                    // 回调版本信息
                    if (otaCallback != null) {
                        otaCallback.onVersionReceived(originalType, versionString);
                    }
                    
                } else {
                    // ⭐ 修复：版本获取超时时不中断OTA更新流程，只记录警告
                    Log.w(TAG, originalType.getDisplayName() + "版本获取超时，但继续OTA更新流程");
                    
                    // 设置默认版本信息，避免后续流程中断
                    switch (originalType) {
                        case CM3:
                            cm3MajorVersion = 0;
                            cm3MinorVersion = 0;
                            cm3PatchVersion = 0;
                            break;
                        case DSP:
                            dspMajorVersion = 0;
                            dspMinorVersion = 0;
                            dspPatchVersion = 0;
                            break;
                        case EXTERNAL_FLASH:
                            externalFlashMajorVersion = 0;
                            externalFlashMinorVersion = 0;
                            externalFlashPatchVersion = 0;
                            break;
                    }
                    
                    // 不调用错误回调，让OTA更新继续
                    Log.w(TAG, "版本获取超时，使用默认版本信息继续OTA更新");
                }
                
            } catch (Exception e) {
                Log.e(TAG, "获取" + originalType.getDisplayName() + "版本信息时发生异常", e);
                
                // ⭐ 修复：异常时不中断OTA更新流程，只记录错误
                Log.w(TAG, originalType.getDisplayName() + "版本获取异常，但继续OTA更新流程");
                
                // 设置默认版本信息
                switch (originalType) {
                    case CM3:
                        cm3MajorVersion = 0;
                        cm3MinorVersion = 0;
                        cm3PatchVersion = 0;
                        break;
                    case DSP:
                        dspMajorVersion = 0;
                        dspMinorVersion = 0;
                        dspPatchVersion = 0;
                        break;
                    case EXTERNAL_FLASH:
                        externalFlashMajorVersion = 0;
                        externalFlashMinorVersion = 0;
                        externalFlashPatchVersion = 0;
                        break;
                }
            }
        }
    }
    
    /**
     * 获取设备当前版本信息
     */
    public String getDeviceVersion() {
        return majorVersion + "." + minorVersion + "." + patchVersion;
    }
    
    /**
     * 获取CM3版本信息
     */
    public String getCm3Version() {
        return cm3MajorVersion + "." + cm3MinorVersion + "." + cm3PatchVersion;
    }
    
    /**
     * 获取DSP版本信息
     */
    public String getDspVersion() {
        return String.format("%d.%d.%d", dspMajorVersion, dspMinorVersion, dspPatchVersion);
    }
    
    /**
     * 获取外部Flash版本信息
     */
    public String getExternalFlashVersion() {
        return String.format("%d.%d.%d", externalFlashMajorVersion, externalFlashMinorVersion, externalFlashPatchVersion);
    }
    
    /**
     * 获取指定OTA类型的版本信息
     */
    public String getVersion(OtaType otaType) {
        switch (otaType) {
            case CM3:
                return getCm3Version();
            case DSP:
                return getDspVersion();
            case EXTERNAL_FLASH:
                return getExternalFlashVersion();
            default:
                return getDeviceVersion();
        }
    }
    
    /**
     * 获取主版本号
     */
    public int getMajorVersion() {
        return majorVersion;
    }
    
    /**
     * 获取次版本号
     */
    public int getMinorVersion() {
        return minorVersion;
    }
    
    /**
     * 获取补丁版本号
     */
    public int getPatchVersion() {
        return patchVersion;
    }
    
    /**
     * 检查版本是否需要更新
     */
    public boolean needsUpdate(String newFirmwarePath) {
        // 这里可以添加版本比较逻辑
        // 例如：比较当前版本和新固件版本
        Log.d(TAG, "当前设备版本: " + getDeviceVersion());
        return true; // 暂时总是返回true，表示需要更新
    }
    
    /**
     * 解析存储基地址和版本信息
     */
    private int parseStorageBaseAddress() {
        if (recvValue == null) {
            Log.w(TAG, "响应数据为空，使用默认基地址");
            return getDefaultBaseAddress();
        }
        
        // 根据当前OTA类型使用不同的解析逻辑
        switch (currentOtaType) {
            case CM3:
                return parseCm3StorageBaseAddress();
            case DSP:
                return parseDspStorageBaseAddress();
            case EXTERNAL_FLASH:
                return parseExternalFlashStorageBaseAddress();
            default:
                Log.w(TAG, "未知OTA类型: " + currentOtaType + "，使用默认基地址");
                return getDefaultBaseAddress();
        }
    }
    
    /**
     * 获取默认基地址
     */
    private int getDefaultBaseAddress() {
        switch (currentOtaType) {
            case CM3:
                return 0x3000;
            case DSP:
                return 0xB3000;
            case EXTERNAL_FLASH:
                return 0x00000000;
            default:
                return 0x3000;
        }
    }
    
    /**
     * 解析CM3 OTA存储基地址
     */
    private int parseCm3StorageBaseAddress() {
        if (recvValue.length < 11) { // 4字节基地址 + 3字节版本信息 + 4字节头部
            Log.w(TAG, "CM3 OTA响应数据无效，使用默认基地址");
            return 0x3000;
        }
        
        // CM3 OTA响应格式：00 01 04 00 XX XX XX XX YY YY YY
        // 其中XX XX XX XX是基地址（小端序），YY YY YY是版本信息
        // 索引0-3: header, 索引4-7: base_address, 索引8-10: version_info
        int baseAddress = (recvValue[4] & 0xFF) |
                         ((recvValue[5] & 0xFF) << 8) |
                         ((recvValue[6] & 0xFF) << 16) |
                         ((recvValue[7] & 0xFF) << 24);
        
        // 解析版本信息
        majorVersion = recvValue[8] & 0xFF;
        minorVersion = recvValue[9] & 0xFF;
        patchVersion = recvValue[10] & 0xFF;
        
        // CM3 OTA地址有效性检查
        if (baseAddress == 0xffffffff || baseAddress == 0) {
            Log.w(TAG, "CM3 OTA: 设备返回无效地址0x" + Integer.toHexString(baseAddress) + "，使用默认地址0x3000");
            baseAddress = 0x3000;
        }
        
        // 存储CM3版本信息
        cm3MajorVersion = majorVersion;
        cm3MinorVersion = minorVersion;
        cm3PatchVersion = patchVersion;
        Log.d(TAG, "存储CM3版本信息: " + majorVersion + "." + minorVersion + "." + patchVersion);
        Log.d(TAG, "CM3 OTA: 设备返回基地址0x" + Integer.toHexString(baseAddress));
        
        return baseAddress;
    }
    
    /**
     * 解析DSP OTA存储基地址
     */
    private int parseDspStorageBaseAddress() {
        if (recvValue.length < 11) { // DSP OTA响应格式：结果码(1) + 操作码(1) + 长度(2) + 基地址(4) + 版本信息(3)
            Log.w(TAG, "DSP OTA响应数据无效，使用默认基地址");
            return 0xB3000;
        }
        
        // DSP OTA响应格式：00 01 07 00 XX XX XX XX YY YY YY
        // 其中XX XX XX XX是基地址（小端序），YY YY YY是版本信息
        // 索引0: 结果码, 索引1: 操作码, 索引2-3: 长度, 索引4-7: base_address, 索引8-10: version_info
        int baseAddress = (recvValue[4] & 0xFF) |
                         ((recvValue[5] & 0xFF) << 8) |
                         ((recvValue[6] & 0xFF) << 16) |
                         ((recvValue[7] & 0xFF) << 24);
        
        // 解析版本信息
        majorVersion = recvValue[8] & 0xFF;
        minorVersion = recvValue[9] & 0xFF;
        patchVersion = recvValue[10] & 0xFF;
        
        // DSP OTA地址有效性检查
        if (baseAddress == 0xfffffffd || baseAddress == 0xffffffff || baseAddress == 0) {
            Log.w(TAG, "DSP OTA: 设备返回无效地址0x" + Integer.toHexString(baseAddress) + "，使用设备端默认计算公式");
            
            // 使用与设备端相同的计算公式：dsp_code_base + image_max_size + dsp_max_size
            int dspCodeBase = 0x80000;      // DSP代码基地址
            int imageMaxSize = 0x30000;     // 镜像最大大小
            int dspMaxSize = 0x10000;       // DSP最大大小
            baseAddress = dspCodeBase + imageMaxSize + dspMaxSize;
            
            Log.d(TAG, "DSP OTA: 使用设备端公式计算的默认地址0x" + Integer.toHexString(baseAddress));
        }
        
        // 存储DSP版本信息
        dspMajorVersion = majorVersion;
        dspMinorVersion = minorVersion;
        dspPatchVersion = patchVersion;
        Log.d(TAG, "存储DSP版本信息: " + majorVersion + "." + minorVersion + "." + patchVersion);
        Log.d(TAG, "DSP OTA: 设备返回基地址0x" + Integer.toHexString(baseAddress));
        
        return baseAddress;
    }
    
    /**
     * 解析外部Flash OTA存储基地址
     */
    private int parseExternalFlashStorageBaseAddress() {
        if (recvValue.length < 12) { // 简化响应格式：result(1) + cmd(1) + addr(4) + len(2) + version_info(4)
            Log.w(TAG, "外部Flash OTA响应数据无效，使用默认基地址");
            return 0x00000000;
        }
        
        // 简化响应格式：result(1) + cmd(1) + addr(4) + len(2) + version_info(4)
        // 索引0: result, 索引1: cmd, 索引2-5: addr, 索引6-7: len, 索引8-11: version_info
        int baseAddress = (recvValue[2] & 0xFF) |
                         ((recvValue[3] & 0xFF) << 8) |
                         ((recvValue[4] & 0xFF) << 16) |
                         ((recvValue[5] & 0xFF) << 24);
        
        // 解析版本信息（如果存在）
        if (recvValue.length >= 12) {
            majorVersion = recvValue[8] & 0xFF;
            minorVersion = recvValue[9] & 0xFF;
            patchVersion = recvValue[10] & 0xFF;
            // 第11字节可能是基地址的一部分
        }
        
        // 存储外部Flash版本信息
        externalFlashMajorVersion = majorVersion;
        externalFlashMinorVersion = minorVersion;
        externalFlashPatchVersion = patchVersion;
        Log.d(TAG, "存储外部Flash版本信息: " + majorVersion + "." + minorVersion + "." + patchVersion);
        
        // 添加Flash OTA详细日志
        Log.d("External Flash OTA", "外部Flash OTA版本信息解析");
        Log.d("External Flash OTA", "服务UUID: " + OTA_SERVICE_UUID_EXTERNAL_FLASH);
        Log.d("External Flash OTA", "版本信息: " + majorVersion + "." + minorVersion + "." + patchVersion);
        
        Log.d(TAG, "外部Flash OTA: 设备返回基地址0x" + Integer.toHexString(baseAddress));
        
        // 添加Flash OTA详细日志
        Log.d("External Flash OTA", "外部Flash OTA基地址解析");
        Log.d("External Flash OTA", "服务UUID: " + OTA_SERVICE_UUID_EXTERNAL_FLASH);
        Log.d("External Flash OTA", "原始响应数据: " + bytesToHexString(recvValue));
        Log.d("External Flash OTA", "解析到的基地址: 0x" + Integer.toHexString(baseAddress));
        
        // 检查外部Flash OTA地址有效性 - 修复：0x0是外部Flash的有效起始地址
        if (baseAddress == 0xffffffff) {
            Log.w(TAG, "外部Flash OTA: 设备返回无效地址0x" + Integer.toHexString(baseAddress) + "，使用默认地址0x00000000");
            Log.w("External Flash OTA", "外部Flash OTA: 设备返回无效地址0x" + Integer.toHexString(baseAddress) + "，使用默认地址0x00000000");
            baseAddress = 0x00000000; // 外部Flash默认从0地址开始
        } else if (baseAddress == 0x0) {
            // 0x0是外部Flash的有效起始地址，这是正常的
            Log.d(TAG, "外部Flash OTA: 设备返回有效起始地址0x0，这是外部Flash的正常起始地址");
            Log.d("External Flash OTA", "外部Flash OTA: 设备返回有效起始地址0x0，这是外部Flash的正常起始地址");
        }
        
        // 记录设备端返回的地址，用于调试
        Log.d(TAG, "外部Flash OTA: 设备端返回的存储基地址: 0x" + Integer.toHexString(baseAddress));
        Log.d(TAG, "外部Flash OTA: 如果地址不是0x00000000，请检查设备端app_otas_flash_get_storage_base()函数");
        
        // 添加Flash OTA最终结果日志
        Log.d("External Flash OTA", "外部Flash OTA基地址解析完成");
        Log.d("External Flash OTA", "最终使用的基地址: 0x" + Integer.toHexString(baseAddress));
        Log.d("External Flash OTA", "如果地址不是0x00000000，请检查设备端app_otas_flash_get_storage_base()函数");
        
        return baseAddress;
    }
    
    /**
     * 清理OTA状态
     */
    private void cleanupOtaState() {
        Log.d(TAG, "清理OTA状态");
        recv_data = 0;
        recvValue = null;
        writeStatus = false;
        isUpdating = false;
        currentPacket = 0;
        totalPackets = 0;
        
        // 重置版本信息
        majorVersion = 0;
        minorVersion = 0;
        patchVersion = 0;
        
        // 重置CM3和DSP版本信息
        cm3MajorVersion = 0;
        cm3MinorVersion = 0;
        cm3PatchVersion = 0;
        dspMajorVersion = 0;
        dspMinorVersion = 0;
        dspPatchVersion = 0;
        
        // 重置外部Flash版本信息
        externalFlashMajorVersion = 0;
        externalFlashMinorVersion = 0;
        externalFlashPatchVersion = 0;
        
        // 重置版本请求标志
        isVersionRequestInProgress = false;
        
        // 重新初始化BLE特征，确保特征状态正确
        if (bleManager != null && bleManager.getBluetoothGatt() != null) {
            Log.d(TAG, "重新初始化BLE特征");
            initCm3OtaService(bleManager.getBluetoothGatt());
            initDspOtaService(bleManager.getBluetoothGatt());
            initExternalFlashOtaService(bleManager.getBluetoothGatt());
        }
        
        // 确保状态正确设置
        if (currentState == OTA_STATE_UPDATING) {
            setState(OTA_STATE_IDLE);
        }
        
        Log.d(TAG, "OTA状态清理完成");
    }
    
    /**
     * 停止OTA更新
     */
    public void stopOtaUpdate() {
        cleanupOtaState();
        setState(OTA_STATE_IDLE);
        Log.d(TAG, "OTA更新已停止");
    }
    
    /**
     * 处理OTA响应数据 (完全按照OTASampleCode1.2.5的协议)
     */
    public void handleOtaResponse(byte[] data) {
        if (data == null || data.length == 0) {
            Log.w(TAG, "收到空的OTA响应数据");
            return;
        }
        
        Log.d(TAG, "收到OTA响应: " + bytesToHexString(data));
        Log.d(TAG, "响应数据长度: " + data.length + " 字节");
        
        // 保存接收到的数据到recvValue，供parseStorageBaseAddress使用
        recvValue = data;
        
        // 解析响应数据，获取操作码
        int opcode = 0;
        if (data.length >= 2) {
            opcode = data[1] & 0xFF; // 第二个字节是操作码
        }
        
        // ⭐ 修复：使用实际的操作码，而不是固定值
        setRecv_data(opcode);
        
        Log.d(TAG, "✅ 设置recv_data为: " + opcode + " (实际操作码)");
    }
    
    /**
     * 处理DSP OTA响应数据
     */
    public void handleDspOtaResponse(byte[] data) {
        if (data != null && data.length >= 4) {
            Log.d(TAG, "收到DSP OTA响应: " + bytesToHexString(data));
            
            // ⭐ 关键修复：保存接收到的数据到recvValue，供parseStorageBaseAddress使用
            recvValue = data;
            
            // 解析响应数据
            int result = data[0] & 0xFF;
            int opcode = data[1] & 0xFF;
            int length = ((data[2] & 0xFF) | ((data[3] & 0xFF) << 8));
            
            Log.d(TAG, "DSP OTA响应 - 结果: " + result + ", 操作码: " + opcode + ", 长度: " + length);
            
            if (result == 0) { // 成功
                // ⭐ 修复：只有成功时才设置recv_data，让等待逻辑继续等待正确的响应
                setRecv_data(opcode); // 使用实际的操作码，而不是固定值1
                setWriteStatus(true);
                Log.d(TAG, "DSP OTA操作成功，设置recv_data为: " + opcode);
            } else {
                // ⭐ 修复：失败时不设置recv_data，让等待逻辑继续等待
                setWriteStatus(false);
                Log.e(TAG, "DSP OTA操作失败，错误码: " + result + "，不设置recv_data，继续等待正确响应");
            }
        } else {
            Log.w(TAG, "DSP OTA响应数据无效或为空");
        }
    }
    
    public void handleExternalFlashOtaResponse(byte[] data) {
        if (data != null && data.length >= 8) {  // 简化响应最小长度：result(1) + cmd(1) + addr(4) + len(2)
            Log.d(TAG, "收到外部Flash OTA响应: " + bytesToHexString(data));
            
            // 添加Flash OTA详细日志
            Log.d("External Flash OTA", "外部Flash OTA收到响应数据");
            Log.d("External Flash OTA", "服务UUID: " + OTA_SERVICE_UUID_EXTERNAL_FLASH);
            Log.d("External Flash OTA", "通知特征UUID: " + OTA_CHAR_UUID_NOTI_EXTERNAL_FLASH);
            Log.d("External Flash OTA", "收到数据: " + bytesToHexString(data));
            Log.d("External Flash OTA", "数据长度: " + data.length + " 字节");
            
            // 添加详细的数据包调试信息
            Log.d(TAG, "=== 设备端响应数据包详情 ===");
            Log.d(TAG, "响应数据总长度: " + data.length + " 字节");
            Log.d(TAG, "完整响应数据: " + bytesToHexString(data));
            
            // 解析简化的响应数据
            int result = data[0] & 0xFF;
            int opcode = data[1] & 0xFF;
            int addr = (data[2] & 0xFF) | ((data[3] & 0xFF) << 8) | 
                      ((data[4] & 0xFF) << 16) | ((data[5] & 0xFF) << 24);
            int length = (data[6] & 0xFF) | ((data[7] & 0xFF) << 8);
            
            Log.d(TAG, "响应解析 - 结果: " + result + ", 操作码: " + opcode + ", 地址: 0x" + Integer.toHexString(addr) + ", 长度: " + length);
            
            // 如果是版本响应，显示详细信息
            if (opcode == OTA_FLASH_CMD_GET_VERSION && data.length >= 12) {
                int major = data[8] & 0xFF;
                int minor = data[9] & 0xFF;
                int patch = data[10] & 0xFF;
                int baseAddr = (data[11] & 0xFF) | ((data[12] & 0xFF) << 8) | 
                              ((data[13] & 0xFF) << 16) | ((data[14] & 0xFF) << 24);
                Log.d(TAG, "版本响应详情:");
                Log.d(TAG, "  版本: " + major + "." + minor + "." + patch);
                Log.d(TAG, "  基地址: 0x" + Integer.toHexString(baseAddr));
                Log.d(TAG, "  响应状态: " + (result == 0 ? "成功" : "失败"));
            }
            Log.d(TAG, "=== 设备端响应数据包详情结束 ===");
            
            // ⭐ 关键修复：保存接收到的数据到recvValue，供parseStorageBaseAddress使用
            recvValue = data;
            
            if (result == OTA_FLASH_RSP_SUCCESS) { // 成功
                // ⭐ 修复：只有成功时才设置recv_data，让等待逻辑继续等待正确的响应
                setRecv_data(opcode); // 使用实际的操作码，而不是固定值1
                setWriteStatus(true);
                Log.d("External Flash OTA", "外部Flash OTA操作成功，设置recv_data为: " + opcode);
            } else {
                // ⭐ 修复：失败时不设置recv_data，让等待逻辑继续等待
                setWriteStatus(false);
                Log.e(TAG, "外部Flash OTA操作失败，错误码: " + result + "，不设置recv_data，继续等待正确响应");
                Log.e("External Flash OTA", "外部Flash OTA操作失败，错误码: " + result + "，不设置recv_data，继续等待正确响应");
            }
        } else {
            Log.w("External Flash OTA", "外部Flash OTA响应数据无效或为空");
        }
    }
    
    /**
     * 检查BLE连接状态
     */
    public boolean isBleConnected() {
        // 首先检查BleManager的连接状态
        boolean bleManagerOk = bleManager != null;
        boolean bleConnected = bleManager != null && bleManager.isConnected();
        boolean gattOk = bleManager != null && bleManager.getBluetoothGatt() != null;
        
        // 如果BleManager已连接，直接返回true
        if (bleManagerOk && bleConnected && gattOk) {
            Log.d(TAG, "BleManager已连接，连接状态正常");
            return true;
        }
        
        // 如果BleManager未连接，检查DeviceFragment的连接状态
        // 通过检查是否有OTA特征可用来判断DeviceFragment是否已连接
        boolean anyOtaAvailable = isCm3OtaAvailable() || isDspOtaAvailable() || isExternalFlashOtaAvailable();
        
        // 如果OTA特征不可用，但BleManager的bluetoothGatt存在，也认为已连接
        // 这是因为DeviceFragment可能正在使用自己的BLE连接
        boolean deviceFragmentConnected = bleManager != null && bleManager.getBluetoothGatt() != null && !bleManager.isUserDisconnected();
        
        if (anyOtaAvailable || deviceFragmentConnected) {
            Log.d(TAG, "DeviceFragment已连接 - OTA特征可用: " + anyOtaAvailable + ", DeviceFragment连接: " + deviceFragmentConnected);
            return true;
        }
        
        // 如果都没有连接，返回false
        Log.d(TAG, "BLE未连接 - BleManager: " + bleConnected + ", DeviceFragment: " + anyOtaAvailable + ", DeviceFragment连接: " + deviceFragmentConnected);
        return false;
    }
    
    /**
     * 检查是否已初始化
     */
    public boolean isInitialized() {
        return bleManager != null && context != null;
    }
    
    /**
     * 检查连接断开状态
     */
    private boolean checkDisconnect() {
        // 检查实际的BLE连接状态，而不是依赖connectState变量
        return !isBleConnected();
    }
    
    /**
     * 获取接收数据标志
     */
    private int getRecv_data() {
        return recv_data;
    }
    
    /**
     * 设置接收数据标志
     */
    private void setRecv_data(int recv_data) {
        this.recv_data = recv_data;
    }
    
    /**
     * 发送OTA命令 (完全按照OTASampleCode1.2.5的协议)
     */
    private boolean send_data(int type, int addr, byte[] buffer, int length) {
        if (!isBleConnected()) {
            Log.e(TAG, "BLE连接状态异常");
            return false;
        }
        
        // 检查BluetoothGatt是否为空
        if (bleManager == null || bleManager.getBluetoothGatt() == null) {
            Log.e(TAG, "BluetoothGatt为空，无法发送数据");
            return false;
        }
        
        // 重置写入状态标志
        writeStatus = false;
        
        // 使用写入锁，防止并发写入冲突
        synchronized (writeLock) {
            byte[] result_cmd;
            byte[] cmd = new byte[OTA_CMD_GET_STR_BASE];
            byte[] cmd_write = cmd_operation(type, length, addr);
            
            // 根据当前OTA类型选择不同的命令处理逻辑
            if (currentOtaType == OtaType.EXTERNAL_FLASH) {
                // 外部Flash OTA命令处理逻辑
                if (type == OTA_FLASH_CMD_GET_VERSION || type == OTA_FLASH_CMD_ERASE_FLASH || 
                    type == OTA_FLASH_CMD_REBOOT) {
                    // 这些命令只需要命令头，不需要数据
                    result_cmd = cmd_write;
                } else if (type == OTA_FLASH_CMD_WRITE_DATA || type == OTA_FLASH_CMD_READ_DATA) {
                    // 写入和读取命令需要合并命令头和数据
                    result_cmd = byteMerger(cmd_write, buffer, length);
                } else {
                    // 其他外部Flash命令使用默认格式
                    result_cmd = cmd_write;
                }
            } else if (currentOtaType == OtaType.DSP) {
                // DSP OTA命令处理逻辑
                if (type == OTA_CMD_DSP_GET_STR_BASE || type == OTA_CMD_DSP_PAGE_ERASE || type == 0 || 
                    type == OTA_CMD_DSP_NVDS_TYPE || type == OTA_CMD_DSP_GET_DATA_BASE || 
                    type == OTA_CMD_DSP_GET_CLK0_BASE || type == OTA_CMD_DSP_GET_CLK1_BASE || 
                    type == OTA_CMD_DSP_GET_CLK2_BASE || type == OTA_CMD_DSP_GET_CLK3_BASE || 
                    type == OTA_CMD_DSP_GET_CLK4_BASE) {
                    result_cmd = cmd_write;
                } else if (type == OTA_CMD_DSP_REBOOT) {
                    // 重启命令使用特殊格式：09 00 00 00 00 00 00 00 00 00 00
                    result_cmd = new byte[11];
                    result_cmd[0] = (byte) (type & 0xFF);  // 09
                    result_cmd[1] = 0x00;  // 00
                    result_cmd[2] = 0x00;  // 00
                    result_cmd[3] = 0x00;  // 00
                    result_cmd[4] = 0x00;  // 00
                    result_cmd[5] = 0x00;  // 00
                    result_cmd[6] = 0x00;  // 00
                    result_cmd[7] = 0x00;  // 00
                    result_cmd[8] = 0x00;  // 00
                    result_cmd[9] = 0x00;  // 00
                    result_cmd[10] = 0x00; // 00
                } else {
                    // DSP写入命令和其他需要数据的命令使用byteMerger
                    result_cmd = byteMerger(cmd_write, buffer, length);
                }
            } else {
                // CM3 OTA命令处理逻辑（默认）
                if (type == OTA_CMD_GET_STR_BASE || type == OTA_CMD_PAGE_ERASE || type == 0 || 
                    type == OTA_CMD_DSP_NVDS_TYPE || type == OTA_CMD_DSP_GET_STR_BASE || 
                    type == OTA_CMD_DSP_PAGE_ERASE || type == OTA_CMD_DSP_GET_DATA_BASE || 
                    type == OTA_CMD_DSP_GET_CLK0_BASE || type == OTA_CMD_DSP_GET_CLK1_BASE || 
                    type == OTA_CMD_DSP_GET_CLK2_BASE || type == OTA_CMD_DSP_GET_CLK3_BASE || 
                    type == OTA_CMD_DSP_GET_CLK4_BASE) {
                    result_cmd = cmd_write;
                } else if (type == OTA_CMD_REBOOT) {
                    // 重启命令使用特殊格式：09 00 00 00 00 00 00 00 00 00 00
                    result_cmd = new byte[11];
                    result_cmd[0] = (byte) (type & 0xFF);  // 09
                    result_cmd[1] = 0x00;  // 00
                    result_cmd[2] = 0x00;  // 00
                    result_cmd[3] = 0x00;  // 00
                    result_cmd[4] = 0x00;  // 00
                    result_cmd[5] = 0x00;  // 00
                    result_cmd[6] = 0x00;  // 00
                    result_cmd[7] = 0x00;  // 00
                    result_cmd[8] = 0x00;  // 00
                    result_cmd[9] = 0x00;  // 00
                    result_cmd[10] = 0x00; // 00
                } else {
                    // CM3写入命令和其他需要数据的命令使用byteMerger
                    result_cmd = byteMerger(cmd_write, buffer, length);
                }
            }
            
            Log.d(TAG, "发送" + currentOtaType.getDisplayName() + " OTA命令: " + bytesToHexString(result_cmd));
            Log.d(TAG, "使用WRITE_TYPE_DEFAULT模式，当前延迟: " + currentDelay + "ms");
            
            // 添加详细的数据包调试信息
            Log.d(TAG, "=== Java端发送数据包详情 ===");
            Log.d(TAG, "命令类型: " + type);
            Log.d(TAG, "数据包总长度: " + result_cmd.length + " 字节");
            Log.d(TAG, "命令头部长度: " + cmd_write.length + " 字节");
            Log.d(TAG, "数据部分长度: " + (buffer != null ? buffer.length : 0) + " 字节");
            Log.d(TAG, "完整数据包内容: " + bytesToHexString(result_cmd));
            
            // 如果是写入命令，显示数据部分的详细信息
            if (buffer != null && buffer.length > 0) {
                Log.d(TAG, "数据部分前32字节: " + bytesToHexString(Arrays.copyOf(buffer, Math.min(32, buffer.length))));
                Log.d(TAG, "数据部分后32字节: " + bytesToHexString(Arrays.copyOfRange(buffer, Math.max(0, buffer.length - 32), buffer.length)));
            }
            Log.d(TAG, "=== Java端发送数据包详情结束 ===");
            
            // 根据当前OTA类型选择对应的特征
            BluetoothGattCharacteristic sendCharacteristic = getSendCharacteristic();
            if (sendCharacteristic == null) {
                Log.e(TAG, currentOtaType.getDisplayName() + " OTA发送特征不可用");
                return false;
            }
            
            Log.d(TAG, "使用发送特征: " + sendCharacteristic.getUuid());
            
            // 添加Flash OTA详细日志
            if (currentOtaType == OtaType.EXTERNAL_FLASH) {
                Log.d("External Flash OTA", "外部Flash OTA写入数据");
                Log.d("External Flash OTA", "服务UUID: " + OTA_SERVICE_UUID_EXTERNAL_FLASH);
                Log.d("External Flash OTA", "特征UUID: " + sendCharacteristic.getUuid());
                Log.d("External Flash OTA", "写入数据: " + bytesToHexString(result_cmd));
                Log.d("External Flash OTA", "数据长度: " + result_cmd.length + " 字节");
            }
            
            // 每次写入前重新设置特征状态，确保特征可写
            try {
                // 重置特征状态，确保可写
                sendCharacteristic.setWriteType(BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT);
                sendCharacteristic.setValue(result_cmd);
                
                // 检查特征是否支持写入
                int properties = sendCharacteristic.getProperties();
                if ((properties & BluetoothGattCharacteristic.PROPERTY_WRITE) == 0 &&
                    (properties & BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE) == 0) {
                    Log.e(TAG, "特征不支持写入操作");
                    return false;
                }
                
            } catch (Exception e) {
                Log.e(TAG, "设置特征状态失败", e);
                return false;
            }
            
            // 添加重试机制，最多重试5次
            int maxRetries = 5;
            // 对于重启命令，减少重试次数
            if (type == OTA_CMD_REBOOT || type == OTA_FLASH_CMD_REBOOT) {
                maxRetries = 1; // 重启命令只重试1次
            }
            
            for (int retry = 0; retry < maxRetries; retry++) {
                try {
                    // ⭐ 修复：在每次重试前检查连接状态
                    if (!isBleConnected()) {
                        Log.w(TAG, "连接已断开，停止重试写入");
                        return false;
                    }
                    
                    // 在写入前等待一段时间，确保设备准备就绪
                    if (retry > 0) {
                        int waitTime = currentDelay * (retry + 1);
                        Log.d(TAG, "重试前等待: " + waitTime + "ms");
                        Thread.sleep(waitTime);
                    }
                    
                    // ⭐ 修复：在写入前再次检查BluetoothGatt是否为空
                    if (bleManager == null || bleManager.getBluetoothGatt() == null) {
                        Log.w(TAG, "BluetoothGatt为空，停止重试写入");
                        return false;
                    }
                    
                    boolean writeResult = bleManager.getBluetoothGatt().writeCharacteristic(sendCharacteristic);
                    Log.d(TAG, "特征写入结果: " + writeResult + " (重试 " + (retry + 1) + "/" + maxRetries + ")");
                    
                    if (!writeResult) {
                        Log.w(TAG, "特征写入失败，等待后重试...");
                        continue;
                    }
                    
                    // 等待写入状态标志，最多等待200ms（增加等待时间）
                    long startTime = System.currentTimeMillis();
                    while (!writeStatus && (System.currentTimeMillis() - startTime) < 200) {
                        Thread.sleep(1);
                    }
                    
                    // 检查写入状态标志，如果为true说明写入成功
                    if (writeStatus) {
                        Log.d(TAG, "✅ 写入状态标志确认成功");
                        // 写入成功，使用当前延迟
                        writeSuccessCount++;
                        writeFailureCount = 0; // 重置失败计数
                        successfulWrites++;
                        totalWrites++;
                        
                        // 更新性能统计
                        long currentTime = System.currentTimeMillis();
                        if (lastWriteTime > 0) {
                            long interval = currentTime - lastWriteTime;
                            averageWriteInterval = (averageWriteInterval * (totalWrites - 1) + interval) / totalWrites;
                        }
                        lastWriteTime = currentTime;
                        
                        // 使用当前延迟，如果连续成功可以适当减少
                        if (writeSuccessCount >= 5 && currentDelay > MIN_DELAY) {
                            currentDelay = Math.max(MIN_DELAY, currentDelay - 2);
                            Log.d(TAG, "连续写入成功，减少延迟到: " + currentDelay + "ms");
                        }
                        
                        return true;
                    } else {
                        Log.w(TAG, "写入状态标志未确认，但特征写入返回true，可能写入成功");
                        // 即使没有收到写入确认，如果特征写入返回true，也认为写入成功
                        writeSuccessCount++;
                        writeFailureCount = 0; // 重置失败计数
                        successfulWrites++;
                        totalWrites++;
                        
                        // 更新性能统计
                        long currentTime = System.currentTimeMillis();
                        if (lastWriteTime > 0) {
                            long interval = currentTime - lastWriteTime;
                            averageWriteInterval = (averageWriteInterval * (totalWrites - 1) + interval) / totalWrites;
                        }
                        lastWriteTime = currentTime;
                        
                        Log.d(TAG, "✅ 特征写入返回成功，认为写入成功");
                        return true;
                    }
                    
                } catch (Exception e) {
                    Log.e(TAG, "特征写入异常", e);
                }
                
                // 写入失败，增加延迟
                writeFailureCount++;
                writeSuccessCount = 0; // 重置成功计数
                currentDelay = Math.min(MAX_DELAY, currentDelay + 5);
                Log.d(TAG, "连续写入失败，增加延迟到: " + currentDelay + "ms");
                Log.d(TAG, "性能统计 - 平均间隔: " + String.format("%.1f", averageWriteInterval) + "ms, 成功率: " + 
                           String.format("%.1f", totalWrites > 0 ? (double) successfulWrites / totalWrites * 100 : 0) + "%");
            }
            
            Log.e(TAG, "特征写入失败，已重试" + maxRetries + "次");
            return false;
        }
    }
    
    /**
     * 获取当前OTA类型的发送特征
     */
    private BluetoothGattCharacteristic getSendCharacteristic() {
        switch (currentOtaType) {
            case CM3:
                return otaSendCharacteristic;
            case DSP:
                return dspOtaSendCharacteristic;
            case EXTERNAL_FLASH:
                return externalFlashOtaRxCharacteristic;  // 外部Flash使用RX特征写入命令
            default:
                return otaSendCharacteristic;
        }
    }
    
    /**
     * 命令操作 (按照OTASampleCode1.2.5的协议)
     */
    private byte[] cmd_operation(int type, int lenth, int addr) {
        byte[] cmd = null;
        
        // ⭐ 修复：根据当前OTA类型选择正确的命令处理逻辑
        switch (currentOtaType) {
            case CM3:
                // CM3 OTA命令处理逻辑
                if (type == OTA_CMD_WRITE_MEM || type == OTA_CMD_WRITE_DATA) {
                    cmd = cmd_write_op(type, OTA_CMD_REBOOT, addr, lenth);
                } else if (type == OTA_CMD_GET_STR_BASE || type == 0) {
                    cmd = cmd_write_op(type, OTA_CMD_PAGE_ERASE, addr, lenth);
                } else if (type == OTA_CMD_PAGE_ERASE) {
                    cmd = cmd_write_op(type, OTA_CMD_WRITE_MEM, addr, OTA_CMD_NVDS_TYPE);
                }
                break;
                
            case DSP:
                // DSP OTA命令处理逻辑
                if (type == OTA_CMD_DSP_WRITE_DATA) {
                    cmd = cmd_write_op(type, OTA_CMD_DSP_REBOOT, addr, lenth);
                } else if (type == OTA_CMD_DSP_GET_STR_BASE || type == OTA_CMD_DSP_NVDS_TYPE || 
                           type == OTA_CMD_DSP_GET_DATA_BASE) {
                    cmd = cmd_write_op(type, OTA_CMD_DSP_PAGE_ERASE, addr, lenth);
                } else if (type == OTA_CMD_DSP_PAGE_ERASE) {
                    cmd = cmd_write_op(type, OTA_CMD_DSP_WRITE_MEM, addr, OTA_CMD_DSP_NVDS_TYPE);
                } else if (type == OTA_CMD_DSP_GET_CLK0_BASE || type == OTA_CMD_DSP_GET_CLK1_BASE || 
                           type == OTA_CMD_DSP_GET_CLK2_BASE || type == OTA_CMD_DSP_GET_CLK3_BASE || 
                           type == OTA_CMD_DSP_GET_CLK4_BASE) {
                    cmd = cmd_write_op(type, OTA_CMD_DSP_PAGE_ERASE, addr, lenth);
                }
                break;
                
            case EXTERNAL_FLASH:
                // 外部Flash OTA命令处理逻辑 - 使用简化的协议
                if (type == OTA_FLASH_CMD_GET_VERSION || type == OTA_FLASH_CMD_REBOOT) {
                    // 这些命令需要完整的7字节格式：cmd(1) + len(2) + addr(4)
                    cmd = new byte[7];
                    cmd[0] = (byte) (type & 0xFF);                    // opcode
                    cmd[1] = (byte) (0 & 0xFF);                         // length低字节 (0)
                    cmd[2] = (byte) ((0 & 0xFF00) >> 8);                // length高字节 (0)
                    cmd[3] = (byte) (addr & 0xFF);                      // addr低字节
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);             // addr高字节
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);          // addr高16位
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);        // addr高24位
                    return cmd;
                } else if (type == OTA_FLASH_CMD_ERASE_FLASH) {
                    // 擦除命令：cmd(1) + len(2) + addr(4) - 使用datalenth参数作为擦除扇区数
                    cmd = new byte[7];
                    cmd[0] = (byte) (type & 0xFF);
                    cmd[1] = (byte) (lenth & 0xFF);                  // length低字节 (擦除扇区数)
                    cmd[2] = (byte) ((lenth & 0xFF00) >> 8);         // length高字节
                    cmd[3] = (byte) (addr & 0xFF);                       // addr低字节 (扇区地址)
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);              // addr高字节
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);           // addr高16位
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);         // addr高24位
                    return cmd;
                } else if (type == OTA_FLASH_CMD_WRITE_DATA) {
                    // Flash写入命令：cmd(1) + len(2) + addr(4) + data_length(2) + data
                    cmd = new byte[9];
                    cmd[0] = (byte) (type & 0xFF);                    // opcode
                    cmd[1] = (byte) (lenth & 0xFF);                  // length低字节 (实际数据长度)
                    cmd[2] = (byte) ((lenth & 0xFF00) >> 8);         // length高字节
                    cmd[3] = (byte) (addr & 0xFF);                      // base_address低字节
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);             // base_address高字节
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);          // base_address高16位
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);        // base_address高24位
                    cmd[7] = (byte) (lenth & 0xFF);                     // write_data.length低字节
                    cmd[8] = (byte) ((lenth & 0xFF00) >> 8);            // write_data.length高字节
                    return cmd;
                } else if (type == OTA_FLASH_CMD_READ_DATA) {
                    // 读取命令：cmd(1) + len(2) + addr(4) + read_length(2)
                    cmd = new byte[9];
                    cmd[0] = (byte) (type & 0xFF);                    // opcode
                    cmd[1] = (byte) (lenth & 0xFF);                  // length低字节 (实际读取长度)
                    cmd[2] = (byte) ((lenth & 0xFF00) >> 8);         // length高字节
                    cmd[3] = (byte) (addr & 0xFF);
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);
                    cmd[7] = (byte) (lenth & 0xFF);                  // read_length低字节 (实际读取长度)
                    cmd[8] = (byte) ((lenth & 0xFF00) >> 8);         // read_length高字节
                    return cmd;
                } else {
                    // 其他外部Flash OTA命令使用默认7字节格式
                    cmd = new byte[7];
                    cmd[0] = (byte) (type & 0xFF);                    // opcode
                    cmd[1] = (byte) (lenth & 0xFF);                    // length低字节
                    cmd[2] = (byte) ((lenth & 0xFF00) >> 8);           // length高字节
                    cmd[3] = (byte) (addr & 0xFF);                      // 参数低字节
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);             // 参数高字节
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);          // 参数高16位
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);        // 参数高24位
                    return cmd;
                }
                
            default:
                // 默认使用CM3 OTA逻辑
                cmd = new byte[7];
                cmd[0] = (byte) (type & 0xFF);                        // opcode
                cmd[1] = (byte) (lenth & 0xFF);                        // length低字节
                cmd[2] = (byte) ((lenth & 0xFF00) >> 8);               // length高字节
                cmd[3] = (byte) (addr & 0xFF);                          // 参数低字节
                cmd[4] = (byte) ((addr & 0xFF00) >> 8);                 // 参数高字节
                cmd[5] = (byte) ((addr & 0xFF0000) >> 16);              // 参数高16位
                cmd[6] = (byte) ((addr & 0xFF000000) >> 24);            // 参数高24位
                return cmd;
        }
        
        // 如果cmd仍然为null，返回默认格式
        if (cmd == null) {
            cmd = new byte[7];
            cmd[0] = (byte) (type & 0xFF);                        // opcode
            cmd[1] = (byte) (lenth & 0xFF);                        // length低字节
            cmd[2] = (byte) ((lenth & 0xFF00) >> 8);               // length高字节
            cmd[3] = (byte) (addr & 0xFF);                          // 参数低字节
            cmd[4] = (byte) ((addr & 0xFF00) >> 8);                 // 参数高字节
            cmd[5] = (byte) ((addr & 0xFF0000) >> 16);              // 参数高16位
            cmd[6] = (byte) ((addr & 0xFF000000) >> 24);            // 参数高24位
        }
        
        return cmd;
    }
    
    /**
     * 命令写入操作 (根据当前OTA类型选择正确的命令处理逻辑)
     */
    private byte[] cmd_write_op(int opcode, int length, int addr, int datalenth) {
        byte[] cmd;
        
        // 根据当前OTA类型选择不同的命令处理逻辑
        switch (currentOtaType) {
            case CM3:
                // CM3 OTA命令处理逻辑
                if (opcode == OTA_CMD_GET_STR_BASE || opcode == OTA_CMD_NVDS_TYPE || 
                    opcode == OTA_CMD_READ_FW_VER || opcode == OTA_CMD_REBOOT) {
                    // 这些命令只需要opcode和length，不需要union字段
                    cmd = new byte[3]; // opcode(1) + length(2)
                    cmd[0] = (byte) (opcode & 0xFF);                    // opcode
                    cmd[1] = (byte) (0 & 0xFF);                         // length低字节 (0)
                    cmd[2] = (byte) ((0 & 0xFF00) >> 8);                // length高字节 (0)
                    return cmd;
                } else if (opcode == OTA_CMD_PAGE_ERASE) {
                    // page_erase命令：opcode(1) + length(2) + base_address(4)
                    cmd = new byte[7];
                    cmd[0] = (byte) (opcode & 0xFF);                    // opcode
                    cmd[1] = (byte) (4 & 0xFF);                         // length低字节 (4字节参数)
                    cmd[2] = (byte) ((4 & 0xFF00) >> 8);                // length高字节
                    cmd[3] = (byte) (addr & 0xFF);                      // base_address低字节
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);             // base_address高字节
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);          // base_address高16位
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);        // base_address高24位
                    return cmd;
                } else if (opcode == OTA_CMD_WRITE_DATA) {
                    // write_data命令：opcode(1) + length(2) + base_address(4) + length(2)
                    cmd = new byte[9];
                    cmd[0] = (byte) (opcode & 0xFF);                    // opcode
                    cmd[1] = (byte) (6 & 0xFF);                         // length低字节 (6字节参数)
                    cmd[2] = (byte) ((6 & 0xFF00) >> 8);                // length高字节
                    cmd[3] = (byte) (addr & 0xFF);                      // base_address低字节
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);             // base_address高字节
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);          // base_address高16位
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);        // base_address高24位
                    cmd[7] = (byte) (datalenth & 0xFF);                 // write_data.length低字节
                    cmd[8] = (byte) ((datalenth & 0xFF00) >> 8);        // write_data.length高字节
                    return cmd;
                } else if (opcode == OTA_CMD_READ_DATA) {
                    // read_data命令：opcode(1) + length(2) + base_address(4) + length(2)
                    cmd = new byte[9];
                    cmd[0] = (byte) (opcode & 0xFF);                    // opcode
                    cmd[1] = (byte) (6 & 0xFF);                         // length低字节 (6字节参数)
                    cmd[2] = (byte) ((6 & 0xFF00) >> 8);                // length高字节
                    cmd[3] = (byte) (addr & 0xFF);                      // base_address低字节
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);             // base_address高字节
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);          // base_address高16位
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);        // base_address高24位
                    cmd[7] = (byte) (datalenth & 0xFF);                 // read_data.length低字节
                    cmd[8] = (byte) ((datalenth & 0xFF00) >> 8);        // read_data.length高字节
                    return cmd;
                } else {
                    // 其他CM3 OTA命令使用默认格式
                    cmd = new byte[7];
                    cmd[0] = (byte) (opcode & 0xFF);                    // opcode
                    cmd[1] = (byte) (length & 0xFF);                    // length低字节
                    cmd[2] = (byte) ((length & 0xFF00) >> 8);           // length高字节
                    cmd[3] = (byte) (addr & 0xFF);                      // 参数低字节
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);             // 参数高字节
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);          // 参数高16位
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);        // 参数高24位
                    return cmd;
                }
                
            case DSP:
                // DSP OTA命令处理逻辑 - 使用DSP特定的命令值
                if (opcode == OTA_CMD_DSP_GET_STR_BASE || opcode == OTA_CMD_DSP_NVDS_TYPE || 
                    opcode == OTA_CMD_DSP_GET_DATA_BASE || opcode == OTA_CMD_DSP_GET_CLK0_BASE ||
                    opcode == OTA_CMD_DSP_GET_CLK1_BASE || opcode == OTA_CMD_DSP_GET_CLK2_BASE ||
                    opcode == OTA_CMD_DSP_GET_CLK3_BASE || opcode == OTA_CMD_DSP_GET_CLK4_BASE) {
                    // DSP OTA命令使用默认格式（7字节）
                    cmd = new byte[7];
                    cmd[0] = (byte) (opcode & 0xFF);                    // opcode
                    cmd[1] = (byte) (length & 0xFF);                    // length低字节
                    cmd[2] = (byte) ((length & 0xFF00) >> 8);           // length高字节
                    cmd[3] = (byte) (addr & 0xFF);                      // 参数低字节
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);             // 参数高字节
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);          // 参数高16位
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);        // 参数高24位
                    return cmd;
                } else if (opcode == OTA_CMD_DSP_PAGE_ERASE) {
                    // DSP OTA擦除命令：opcode(1) + length(2) + base_address(4)
                    cmd = new byte[7];
                    cmd[0] = (byte) (opcode & 0xFF);                    // opcode
                    cmd[1] = (byte) (4 & 0xFF);                         // length低字节 (4字节参数)
                    cmd[2] = (byte) ((4 & 0xFF00) >> 8);                // length高字节
                    cmd[3] = (byte) (addr & 0xFF);                      // base_address低字节
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);             // base_address高字节
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);          // base_address高16位
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);        // base_address高24位
                    return cmd;
                } else if (opcode == OTA_CMD_DSP_WRITE_DATA) {
                    // DSP OTA写入命令：opcode(1) + length(2) + base_address(4) + length(2)
                    cmd = new byte[9];
                    cmd[0] = (byte) (opcode & 0xFF);                    // opcode
                    cmd[1] = (byte) (6 & 0xFF);                         // length低字节 (6字节参数)
                    cmd[2] = (byte) ((6 & 0xFF00) >> 8);                // length高字节
                    cmd[3] = (byte) (addr & 0xFF);                      // base_address低字节
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);             // base_address高字节
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);          // base_address高16位
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);        // base_address高24位
                    cmd[7] = (byte) (datalenth & 0xFF);                 // write_data.length低字节
                    cmd[8] = (byte) ((datalenth & 0xFF00) >> 8);        // write_data.length高字节
                    return cmd;
                } else {
                    // 其他DSP OTA命令使用默认格式
                    cmd = new byte[7];
                    cmd[0] = (byte) (opcode & 0xFF);                    // opcode
                    cmd[1] = (byte) (length & 0xFF);                    // length低字节
                    cmd[2] = (byte) ((length & 0xFF00) >> 8);           // length高字节
                    cmd[3] = (byte) (addr & 0xFF);                      // 参数低字节
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);             // 参数高字节
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);          // 参数高16位
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);        // 参数高24位
                    return cmd;
                }
                
            case EXTERNAL_FLASH:
                // 外部Flash OTA命令处理逻辑 - 简化协议
                if (opcode == OTA_FLASH_CMD_GET_VERSION || opcode == OTA_FLASH_CMD_REBOOT) {
                    // 需要完整的7字节格式：cmd(1) + len(2) + addr(4)
                    cmd = new byte[7];
                    cmd[0] = (byte) (opcode & 0xFF);
                    cmd[1] = 0;  // length低字节 (0)
                    cmd[2] = 0;  // length高字节 (0)
                    cmd[3] = (byte) (addr & 0xFF);                      // addr低字节
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);             // addr高字节
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);          // addr高16位
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);        // addr高24位
                    return cmd;
                } else if (opcode == OTA_FLASH_CMD_ERASE_FLASH) {
                    // 擦除命令：cmd(1) + len(2) + addr(4) - 使用datalenth参数作为擦除扇区数
                    cmd = new byte[7];
                    cmd[0] = (byte) (opcode & 0xFF);
                    cmd[1] = (byte) (datalenth & 0xFF);                  // length低字节 (擦除扇区数)
                    cmd[2] = (byte) ((datalenth & 0xFF00) >> 8);         // length高字节
                    cmd[3] = (byte) (addr & 0xFF);                       // addr低字节 (扇区地址)
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);              // addr高字节
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);           // addr高16位
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);         // addr高24位
                    return cmd;
                } else if (opcode == OTA_FLASH_CMD_WRITE_DATA) {
                    // 写入命令：cmd(1) + len(2) + addr(4) + data_length(2)
                    cmd = new byte[9];
                    cmd[0] = (byte) (opcode & 0xFF);
                    cmd[1] = (byte) (datalenth & 0xFF);                  // length低字节 (实际数据长度)
                    cmd[2] = (byte) ((datalenth & 0xFF00) >> 8);         // length高字节
                    cmd[3] = (byte) (addr & 0xFF);
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);
                    cmd[7] = (byte) (datalenth & 0xFF);
                    cmd[8] = (byte) ((datalenth & 0xFF00) >> 8);
                    return cmd;
                } else if (opcode == OTA_FLASH_CMD_READ_DATA) {
                    // 读取命令：cmd(1) + len(2) + addr(4) + read_length(2)
                    cmd = new byte[9];
                    cmd[0] = (byte) (opcode & 0xFF);
                    cmd[1] = (byte) (length & 0xFF);                  // length低字节 (实际读取长度)
                    cmd[2] = (byte) ((length & 0xFF00) >> 8);         // length高字节
                    cmd[3] = (byte) (addr & 0xFF);
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);
                    cmd[7] = (byte) (datalenth & 0xFF);                  // read_length低字节 (实际读取长度)
                    cmd[8] = (byte) ((datalenth & 0xFF00) >> 8);         // read_length高字节
                    return cmd;
                } else {
                    // 其他命令默认7字节格式
                    cmd = new byte[7];
                    cmd[0] = (byte) (opcode & 0xFF);
                    cmd[1] = (byte) (length & 0xFF);
                    cmd[2] = (byte) ((length & 0xFF00) >> 8);
                    cmd[3] = (byte) (addr & 0xFF);
                    cmd[4] = (byte) ((addr & 0xFF00) >> 8);
                    cmd[5] = (byte) ((addr & 0xFF0000) >> 16);
                    cmd[6] = (byte) ((addr & 0xFF000000) >> 24);
                    return cmd;
                }
                
            default:
                // 默认使用CM3 OTA逻辑
                cmd = new byte[7];
                cmd[0] = (byte) (opcode & 0xFF);                        // opcode
                cmd[1] = (byte) (length & 0xFF);                        // length低字节
                cmd[2] = (byte) ((length & 0xFF00) >> 8);               // length高字节
                cmd[3] = (byte) (addr & 0xFF);                          // 参数低字节
                cmd[4] = (byte) ((addr & 0xFF00) >> 8);                 // 参数高字节
                cmd[5] = (byte) ((addr & 0xFF0000) >> 16);              // 参数高16位
                cmd[6] = (byte) ((addr & 0xFF000000) >> 24);            // 参数高24位
                return cmd;
        }


 
    }
    
    /**
     * 字节数组合并 (按照OTASampleCode1.2.5的协议)
     */
    private static byte[] byteMerger(byte[] byte_1, byte[] byte_2, int byte_2_len) {
        byte[] byte_3 = new byte[byte_1.length + byte_2_len];
        System.arraycopy(byte_1, 0, byte_3, 0, byte_1.length);
        System.arraycopy(byte_2, 0, byte_3, byte_1.length, byte_2_len);
        return byte_3;
    }
    
    /**
     * 字节数组转十六进制字符串 (按照OTASampleCode1.2.5的协议)
     */
    private static String bytesToHexString(byte[] src) {
        StringBuilder stringBuilder = new StringBuilder();
        if (src == null || src.length <= 0) {
            return "";
        }
        for (byte b : src) {
            int v = b & 0xFF;
            String hv = Integer.toHexString(v).toUpperCase();
            if (hv.length() < 2) {
                stringBuilder.append(0);
            }
            stringBuilder.append(hv).append(" ");
        }
        return stringBuilder.toString();
    }
    
    /**
     * 测试OTA连接
     */
    public void testOtaConnection(OtaCallback callback) {
        if (!isBleConnected()) {
            Log.e(TAG, "BLE连接状态异常，无法测试OTA连接");
            if (callback != null) {
                callback.onError("BLE连接状态异常");
            }
            return;
        }
        
        Log.d(TAG, "开始测试OTA连接，类型: " + currentOtaType.getDisplayName());
        
        new Thread(() -> {
            try {
                // 根据当前OTA类型选择正确的测试命令
                int testCommand = getGetStrBaseCommand();
                
                // 发送测试命令
                if (!send_data(testCommand, 0, null, 1024)) {
                    throw new IOException("发送测试命令失败");
                }
                
                // 等待响应
                while (getRecv_data() != testCommand) {
                    if (checkDisconnect()) {
                        throw new IOException("设备连接断开");
                    }
                    Thread.sleep(10);
                }
                setRecv_data(0);
                
                Log.d(TAG, "OTA连接测试成功，类型: " + currentOtaType.getDisplayName());
                if (callback != null) {
                    callback.onSuccess("OTA连接测试成功");
                }
                
            } catch (Exception e) {
                Log.e(TAG, "OTA连接测试失败，类型: " + currentOtaType.getDisplayName(), e);
                if (callback != null) {
                    callback.onError("OTA连接测试失败: " + e.getMessage());
                }
            }
        }).start();
    }

    /**
     * 设置MTU大小（由BleManager回调调用）
     */
    public void setMtuSize(int mtu) {
        this.mtuSize = mtu;
        // 动态调整包大小，但不超过MTU限制
        this.maxPacketSize = Math.min(512, mtu - 9);
        Log.d(TAG, "OtaManager收到MTU设置: " + mtu + ", 优化包大小: " + maxPacketSize);
    }
    
    /**
     * 优化传输参数
     */
    public void optimizeTransfer() {
        // 尝试请求更大的MTU
        if (bleManager != null && bleManager.getBluetoothGatt() != null) {
            // 请求最大MTU大小
            bleManager.getBluetoothGatt().requestMtu(512);
            Log.d(TAG, "请求MTU大小: 512");
        }
        
        // 移除写入类型设置，避免与send_data中的设置冲突
        // 在send_data中会根据需要动态设置写入类型
        Log.d(TAG, "传输参数优化完成");
    }

    /**
     * 等待OTA响应（带超时机制）- 优化版本，减少日志输出
     */
    private boolean waitForResponseWithTimeout(int expectedCommand, long timeoutMs) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        long endTime = startTime + timeoutMs;
        
        Log.d(TAG, "开始等待OTA响应，期望命令: " + expectedCommand + ", 超时时间: " + timeoutMs + "ms");
        Log.d(TAG, "当前recv_data初始值: " + getRecv_data());
        
        // ⭐ 修复：版本请求不依赖于isUpdating标志，避免被中断
        while (System.currentTimeMillis() < endTime) {
            if (getRecv_data() == expectedCommand) {
                Log.d(TAG, "✅ 收到期望的OTA响应: " + expectedCommand);
                return true;
            }
            
            // 减少连接状态检查频率，避免频繁调用isBleConnected
            if ((System.currentTimeMillis() - startTime) % 2000 < 10) { // 每2秒检查一次连接状态，从1秒改为2秒
                if (!isBleConnected()) {
                    Log.e(TAG, "设备连接断开，等待响应失败");
                    return false;
                }
            }
            
            Thread.sleep(2); // 从5ms减少到2ms，提高响应速度
        }
        
        Log.e(TAG, "❌ 等待OTA响应超时，期望命令: " + expectedCommand + ", 超时时间: " + timeoutMs + "ms");
        Log.e(TAG, "最终recv_data值: " + getRecv_data());
        return false;
    }

    /**
     * 获取OTA状态信息（用于调试）
     */
    public String getOtaStatusInfo() {
        StringBuilder info = new StringBuilder();
        info.append("OTA状态信息:\n");
        info.append("- 当前状态: ").append(currentState).append("\n");
        info.append("- 更新进度: ").append(updateProgress).append("%\n");
        info.append("- 当前状态描述: ").append(currentStatus).append("\n");
        info.append("- 设备版本: ").append(getDeviceVersion()).append("\n");
        info.append("- CM3版本: ").append(getCm3Version()).append("\n");
        info.append("- DSP版本: ").append(getDspVersion()).append("\n");
        info.append("- 外部Flash版本: ").append(getExternalFlashVersion()).append("\n");
        info.append("- 是否正在更新: ").append(isUpdating).append("\n");
        info.append("- 当前包: ").append(currentPacket).append("/").append(totalPackets).append("\n");
        info.append("- MTU大小: ").append(mtuSize).append("\n");
        info.append("- 接收数据标志: ").append(recv_data).append("\n");
        info.append("- BLE连接状态: ").append(isBleConnected()).append("\n");
        info.append("- OTA发送特征: ").append(otaSendCharacteristic != null ? "已设置" : "未设置").append("\n");
        info.append("- OTA接收特征: ").append(otaRecvCharacteristic != null ? "已设置" : "未设置").append("\n");
        
        if (firmwareData != null) {
            info.append("- 固件数据大小: ").append(firmwareData.length).append(" 字节\n");
        }
        
        if (recvValue != null) {
            info.append("- 最后接收数据: ").append(bytesToHexString(recvValue)).append("\n");
        }
        
        return info.toString();
    }

    /**
     * 获取当前OTA类型
     */
    public OtaType getCurrentOtaType() {
        synchronized (otaTypeLock) {
            return currentOtaType;
        }
    }
    
    /**
     * 检查CM3 OTA是否可用
     */
    public boolean isCm3OtaAvailable() {
        return otaSendCharacteristic != null && otaRecvCharacteristic != null;
    }
    
    /**
     * 检查DSP OTA是否可用
     */
    public boolean isDspOtaAvailable() {
        return dspOtaSendCharacteristic != null && dspOtaRecvCharacteristic != null && 
               dspOtaNotiCharacteristic != null && dspOtaVersionInfoCharacteristic != null;
    }
    
    public boolean isExternalFlashOtaAvailable() {
        return externalFlashOtaRxCharacteristic != null && externalFlashOtaTxCharacteristic != null && 
               externalFlashOtaNotiCharacteristic != null && externalFlashOtaVersionInfoCharacteristic != null;
    }
    
    /**
     * 获取可用的OTA类型列表
     */
    public List<OtaType> getAvailableOtaTypes() {
        List<OtaType> availableTypes = new ArrayList<>();
        if (isCm3OtaAvailable()) {
            availableTypes.add(OtaType.CM3);
        }
        if (isDspOtaAvailable()) {
            availableTypes.add(OtaType.DSP);
        }
        if (isExternalFlashOtaAvailable()) {
            availableTypes.add(OtaType.EXTERNAL_FLASH);
        }
        return availableTypes;
    }

    // 添加特征状态缓存，避免重复日志
    private boolean lastCm3Available = false;
    private boolean lastDspAvailable = false;
    private boolean lastExternalFlashAvailable = false;

    /**
     * 检查指定OTA类型的特征是否可用
     */
    private boolean isOtaCharacteristicsAvailable(OtaType otaType) {
        boolean result = false;
        switch (otaType) {
            case CM3:
                result = otaSendCharacteristic != null && otaRecvCharacteristic != null;
                // 只在状态发生变化时才输出日志
                if (result != lastCm3Available) {
                    if (!result) {
                        Log.d(TAG, "CM3 OTA特征检查 - 发送特征: " + (otaSendCharacteristic != null ? "已设置" : "未设置"));
                        Log.d(TAG, "CM3 OTA特征检查 - 接收特征: " + (otaRecvCharacteristic != null ? "已设置" : "未设置"));
                    }
                    lastCm3Available = result;
                    Log.d(TAG, otaType.getDisplayName() + " OTA特征可用性: " + result);
                }
                break;
            case DSP:
                result = dspOtaSendCharacteristic != null && dspOtaRecvCharacteristic != null;
                // 只在状态发生变化时才输出日志
                if (result != lastDspAvailable) {
                    if (!result) {
                        Log.d(TAG, "DSP OTA特征检查 - 发送特征: " + (dspOtaSendCharacteristic != null ? "已设置" : "未设置"));
                        Log.d(TAG, "DSP OTA特征检查 - 接收特征: " + (dspOtaRecvCharacteristic != null ? "已设置" : "未设置"));
                    }
                    lastDspAvailable = result;
                    Log.d(TAG, otaType.getDisplayName() + " OTA特征可用性: " + result);
                }
                break;
            case EXTERNAL_FLASH:
                result = externalFlashOtaRxCharacteristic != null && externalFlashOtaTxCharacteristic != null && 
                        externalFlashOtaNotiCharacteristic != null && externalFlashOtaVersionInfoCharacteristic != null;
                // 只在状态发生变化时才输出日志
                if (result != lastExternalFlashAvailable) {
                    if (!result) {
                        Log.d(TAG, "外部Flash OTA特征检查 - RX特征(写入): " + (externalFlashOtaRxCharacteristic != null ? "已设置" : "未设置"));
                        Log.d(TAG, "外部Flash OTA特征检查 - TX特征(读取): " + (externalFlashOtaTxCharacteristic != null ? "已设置" : "未设置"));
                        Log.d(TAG, "外部Flash OTA特征检查 - 通知特征: " + (externalFlashOtaNotiCharacteristic != null ? "已设置" : "未设置"));
                        Log.d(TAG, "外部Flash OTA特征检查 - 版本信息特征: " + (externalFlashOtaVersionInfoCharacteristic != null ? "已设置" : "未设置"));
                    }
                    lastExternalFlashAvailable = result;
                    Log.d(TAG, otaType.getDisplayName() + " OTA特征可用性: " + result);
                }
                break;
            default:
                result = false;
                break;
        }
        
        return result;
    }

    /**
     * 完全重置所有OTA状态
     */
    private void resetAllState() {
        Log.d(TAG, "完全重置所有OTA状态");
        currentState = OTA_STATE_IDLE;
        updateProgress = 0;
        currentStatus = "准备就绪";
        firmwareFile = null;
        firmwareData = null;
        currentOtaType = OtaType.CM3; // 默认CM3
        recv_data = 0;
        recvValue = null;
        writeStatus = false;
        isUpdating = false;
        currentPacket = 0;
        totalPackets = 0;
        majorVersion = 0;
        minorVersion = 0;
        patchVersion = 0;
        
        // 重置动态延迟参数
        writeSuccessCount = 0;
        writeFailureCount = 0;
        currentDelay = 30; // 重置为初始延迟30ms
        
        // 重置连接参数
        connectionIntervalMs = 7.5;
        connectionLatency = 0;
        connectionTimeoutMs = 500;
        connectionParametersUpdated = false;
        
        // 重置性能统计
        lastWriteTime = 0;
        totalWrites = 0;
        successfulWrites = 0;
        averageWriteInterval = 0;
        
        // 重新初始化BLE特征，确保特征状态正确
        if (bleManager != null && bleManager.getBluetoothGatt() != null) {
            Log.d(TAG, "重新初始化BLE特征");
            initCm3OtaService(bleManager.getBluetoothGatt());
            initDspOtaService(bleManager.getBluetoothGatt());
            initExternalFlashOtaService(bleManager.getBluetoothGatt());
        }
    }
    
    /**
     * 强制重置所有状态（公共方法，供外部调用）
     */
    public void forceReset() {
        Log.d(TAG, "强制重置所有OTA状态");
        resetAllState();
        setState(OTA_STATE_IDLE);
    }

    /**
     * 更新连接参数（由BleManager回调调用）
     */
    public void updateConnectionParameters(double intervalMs, int latency, int timeout) {
        Log.d(TAG, "=== 连接参数更新 ===");
        Log.d(TAG, "间隔: " + intervalMs + "ms");
        Log.d(TAG, "延迟: " + latency + " (跳过的连接事件数)");
        Log.d(TAG, "超时: " + timeout + "ms");
        
        // 验证连接参数的有效性
        if (intervalMs < 7.5 || intervalMs > 4000) {
            Log.w(TAG, "连接间隔超出有效范围(7.5ms-4000ms): " + intervalMs + "ms");
            return;
        }
        
        // 计算连接间隔的BLE单位值
        int intervalUnits = (int) Math.round(intervalMs / 1.25);
        Log.d(TAG, "连接参数分析 - 有效间隔: " + intervalMs + "ms");
        
        // ⭐ 修复：使用更保守的延迟策略，确保稳定传输
        Log.d(TAG, "使用保守延迟策略，确保稳定传输");
        currentDelay = calculateConservativeDelay();
        Log.d(TAG, "计算最优延迟: " + currentDelay + "ms (基于连接间隔: " + intervalMs + "ms)");
        
        // 更新连接参数
        connectionIntervalMs = intervalMs;
        connectionLatency = latency;
        connectionTimeoutMs = timeout;
        connectionParametersUpdated = true;
        
        Log.d(TAG, "连接参数已更新 - 间隔: " + intervalMs + "ms, 延迟: " + latency + ", 超时: " + timeout + "ms, 当前延迟: " + currentDelay + "ms");
    }
    
    /**
     * 根据连接参数计算最优延迟
     */
    private void calculateOptimalDelay() {
        if (!connectionParametersUpdated) {
            Log.d(TAG, "连接参数未更新，使用保守延迟策略");
            return;
        }
        
        // 计算有效连接间隔（考虑延迟）
        double effectiveIntervalMs = connectionIntervalMs * (1 + connectionLatency);
        
        Log.d(TAG, "连接参数分析 - 有效间隔: " + effectiveIntervalMs + "ms");
        Log.d(TAG, "使用保守延迟策略，确保稳定传输");
        
        // 使用保守的延迟策略，确保延迟大于连接间隔
        int minDelay = (int) Math.max(30, effectiveIntervalMs * 2);
        currentDelay = Math.max(MIN_DELAY, Math.min(MAX_DELAY, minDelay));
        
        Log.d(TAG, "计算最优延迟: " + currentDelay + "ms (基于连接间隔: " + effectiveIntervalMs + "ms)");
    }
    
    /**
     * 根据连接参数计算最小允许延迟
     */
    private int calculateMinAllowedDelay() {
        // 使用保守的最小延迟策略
        return 30;
    }
    
    /**
     * 强制重新初始化OTA特征
     */
    public void reinitializeOtaCharacteristics() {
        Log.d(TAG, "强制重新初始化OTA特征");
        if (bleManager != null && bleManager.getBluetoothGatt() != null) {
            // 清空现有特征引用
            otaSendCharacteristic = null;
            otaRecvCharacteristic = null;
            dspOtaSendCharacteristic = null;
            dspOtaRecvCharacteristic = null;
            dspOtaNotiCharacteristic = null;
            dspOtaVersionInfoCharacteristic = null;
            
            // 重置状态缓存
            lastCm3Available = false;
            lastDspAvailable = false;
            lastExternalFlashAvailable = false;
            
            // 重新初始化
            initCm3OtaService(bleManager.getBluetoothGatt());
            initDspOtaService(bleManager.getBluetoothGatt());
            initExternalFlashOtaService(bleManager.getBluetoothGatt());
            
            Log.d(TAG, "OTA特征重新初始化完成");
            // 只在状态发生变化时才输出日志
            boolean cm3Available = isCm3OtaAvailable();
            boolean dspAvailable = isDspOtaAvailable();
            boolean externalFlashAvailable = isExternalFlashOtaAvailable();
            if (cm3Available != lastCm3Available || dspAvailable != lastDspAvailable || externalFlashAvailable != lastExternalFlashAvailable) {
                Log.d(TAG, "CM3 OTA特征: " + (cm3Available ? "可用" : "不可用"));
                Log.d(TAG, "DSP OTA特征: " + (dspAvailable ? "可用" : "不可用"));
                Log.d(TAG, "外部Flash OTA特征: " + (externalFlashAvailable ? "可用" : "不可用"));
            }
        } else {
            Log.w(TAG, "BLE管理器或Gatt不可用，无法重新初始化OTA特征");
        }
    }
    
    /**
     * 连接建立后重新初始化OTA特征（由BleManager调用）
     */
    public void onConnectionEstablished() {
        Log.d(TAG, "连接建立，重新初始化OTA特征");
        // 延迟一点时间，确保GATT服务发现完成
        new android.os.Handler(android.os.Looper.getMainLooper()).postDelayed(() -> {
            if (bleManager != null && bleManager.getBluetoothGatt() != null) {
                Log.d(TAG, "开始重新初始化OTA特征");
                reinitializeOtaCharacteristics();
            } else {
                Log.d(TAG, "BleManager或BluetoothGatt为空，跳过OTA特征初始化");
            }
        }, 500); // 延迟1秒，确保服务发现完成
    }
    
    /**
     * 强制等待前一个OTA完成（用于连续OTA）
     */
    public void waitForPreviousOtaComplete() {
        Log.d(TAG, "等待前一个OTA完成...");
        
        // 等待当前OTA状态变为非更新状态
        int maxWaitTime = 30000; // 最多等待30秒
        int waitInterval = 1000; // 每秒检查一次
        int totalWaitTime = 0;
        
        while ((currentState == OTA_STATE_UPDATING || isUpdating) && totalWaitTime < maxWaitTime) {
            try {
                Thread.sleep(waitInterval);
                totalWaitTime += waitInterval;
                Log.d(TAG, "等待前一个OTA完成... " + totalWaitTime + "ms");
            } catch (InterruptedException e) {
                Log.w(TAG, "等待前一个OTA完成被中断");
                Thread.currentThread().interrupt();
                break;
            }
        }
        
        if (totalWaitTime >= maxWaitTime) {
            Log.w(TAG, "等待前一个OTA完成超时，强制重置状态");
            forceReset();
        } else {
            Log.d(TAG, "前一个OTA已完成，可以开始新的OTA");
        }
        
        // 额外等待一段时间，确保设备状态稳定
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Log.w(TAG, "额外等待被中断");
            Thread.currentThread().interrupt();
        }
    }
    
    /**
     * 检查是否已获取所有OTA类型的版本信息
     */
    public boolean hasAllVersionInfo() {
        boolean hasCm3Version = (cm3MajorVersion != 0 || cm3MinorVersion != 0 || cm3PatchVersion != 0);
        boolean hasDspVersion = (dspMajorVersion != 0 || dspMinorVersion != 0 || dspPatchVersion != 0);
        
        Log.d(TAG, "版本信息检查 - CM3: " + (hasCm3Version ? "已获取" : "未获取") + 
                   " (" + getCm3Version() + "), DSP: " + (hasDspVersion ? "已获取" : "未获取") + 
                   " (" + getDspVersion() + ")");
        
        return hasCm3Version && hasDspVersion;
    }
    
    /**
     * 检查是否已获取指定OTA类型的版本信息
     */
    public boolean hasVersionInfo(OtaType otaType) {
        switch (otaType) {
            case CM3:
                return cm3MajorVersion > 0 || cm3MinorVersion > 0 || cm3PatchVersion > 0;
            case DSP:
                return dspMajorVersion > 0 || dspMinorVersion > 0 || dspPatchVersion > 0;
            case EXTERNAL_FLASH:
                return externalFlashMajorVersion > 0 || externalFlashMinorVersion > 0 || externalFlashPatchVersion > 0;
            default:
                return false;
        }
    }

    /**
     * 读取基地址并回调（不影响OTA流程）
     * @param otaType 读取类型
     * @param callback 回调 (baseAddr, version)
     */
    public void readBaseAddress(OtaType otaType, BaseAddressCallback callback) {
        if (!isBleConnected()) {
            if (callback != null) {
                callback.onResult(-1, "设备未连接");
            }
            return;
        }
        
        // ⭐ 关键修复：使用同步锁保护currentOtaType，确保在版本请求过程中不会被其他线程修改
        synchronized (otaTypeLock) {
            // 设置当前OTA类型，确保使用正确的命令和特征
            OtaType originalType = currentOtaType;
            currentOtaType = otaType;
            
            Log.d(TAG, "开始读取" + otaType.getDisplayName() + "基地址");
            
            // 根据OTA类型选择不同的命令
            int command;
            switch (otaType) {
                case CM3:
                    command = OTA_CMD_GET_STR_BASE;
                    break;
                case DSP:
                    command = OTA_CMD_DSP_GET_STR_BASE;
                    break;
                case EXTERNAL_FLASH:
                    command = OTA_FLASH_CMD_GET_VERSION;  // 使用简化的版本获取命令
                    break;
                default:
                    if (callback != null) {
                        callback.onResult(-1, "不支持的OTA类型");
                    }
                    // 恢复原始OTA类型
                    currentOtaType = originalType;
                    return;
            }
            
            // 发送获取基地址命令
            if (send_data(command, 0, null, 0)) {
                // 等待响应
                try {
                    if (waitForResponseWithTimeout(command, 5000)) {
                        // 解析响应获取基地址
                        int baseAddr = parseStorageBaseAddress();
                        String version = getVersion(otaType);
                        Log.d(TAG, otaType.getDisplayName() + "基地址读取成功: 0x" + Integer.toHexString(baseAddr) + ", 版本: " + version);
                        if (callback != null) {
                            callback.onResult(baseAddr, version);
                        }
                    } else {
                        Log.e(TAG, otaType.getDisplayName() + "基地址读取超时");
                        if (callback != null) {
                            callback.onResult(-1, "读取基地址超时");
                        }
                    }
                } catch (InterruptedException e) {
                    Log.e(TAG, otaType.getDisplayName() + "基地址读取被中断", e);
                    if (callback != null) {
                        callback.onResult(-1, "读取基地址被中断");
                    }
                }
            } else {
                Log.e(TAG, otaType.getDisplayName() + "发送基地址读取命令失败");
                if (callback != null) {
                    callback.onResult(-1, "发送基地址读取命令失败");
                }
            }
            
            // 恢复原始OTA类型
            currentOtaType = originalType;
        }
    }

    public interface BaseAddressCallback {
        void onResult(int baseAddr, String version);
    }

    /**
     * 设置写入状态标志（供BleManager回调使用）
     */
    public void setWriteStatus(boolean status) {
        this.writeStatus = status;
        //Log.d(TAG, "设置写入状态标志: " + status);
    }
    
    /**
     * 获取写入状态标志
     */
    public boolean getWriteStatus() {
        return writeStatus;
    }
    
    /**
     * 检查是否正在更新
     */
    public boolean isUpdating() {
        return isUpdating;
    }

    /**
     * 计算保守的延迟时间
     */
    private int calculateConservativeDelay() {
        // 基于连接间隔计算保守的延迟时间
        // 使用连接间隔的4倍作为延迟，确保有足够的时间处理
        int conservativeDelay = (int) Math.max(connectionIntervalMs * 4, MIN_DELAY);
        return Math.min(conservativeDelay, MAX_DELAY);
    }

    /**
     * 检查OTA升级（在版本信息获取完成后调用）
     */
    private void checkOtaUpgrade() {
        Log.d(TAG, "开始检查OTA升级...");
        
        // 检查是否已获取到所有版本信息
        if (!hasAllVersionInfo()) {
            Log.w(TAG, "版本信息不完整，跳过OTA升级检查");
            return;
        }
        
        // 检查是否有可用的OTA类型
        List<OtaType> availableTypes = getAvailableOtaTypes();
        if (availableTypes.isEmpty()) {
            Log.w(TAG, "没有可用的OTA类型，跳过OTA升级检查");
            return;
        }
        
        Log.d(TAG, "可用的OTA类型: " + availableTypes.size());
        for (OtaType type : availableTypes) {
            String version = getVersion(type);
            Log.d(TAG, type.getDisplayName() + " 版本: " + version);
        }
        
        // 这里可以添加具体的升级逻辑
        // 例如：检查服务器是否有新版本，比较版本号等
        Log.d(TAG, "OTA升级检查完成");
        
        // 如果有回调，通知版本信息已更新
        if (otaCallback != null) {
            for (OtaType type : availableTypes) {
                String version = getVersion(type);
                if (version != null && !version.isEmpty()) {
                    otaCallback.onVersionReceived(type, version);
                }
            }
            
            // 通知版本检查完成，让MainActivity可以执行checkOtaUpgrade
            otaCallback.onVersionCheckComplete();
        }
    }
} 